+2010-08-25 Nick Clifton <nickc@redhat.com>
+
+ * archive.cc: Formatting fixes: Remove whitespace between
+ typename and following asterisk. Remove whitespace between
+ function name and opening parenthesis.
+ * archive.h: Likewise.
+ * arm.cc: Likewise.
+ * attributes.cc: Likewise.
+ * attributes.h: Likewise.
+ * common.cc: Likewise.
+ * copy-relocs.cc: Likewise.
+ * dirsearch.h: Likewise.
+ * dynobj.cc: Likewise.
+ * ehframe.cc: Likewise.
+ * ehframe.h: Likewise.
+ * expression.cc: Likewise.
+ * fileread.cc: Likewise.
+ * fileread.h: Likewise.
+ * gc.h: Likewise.
+ * gold-threads.cc: Likewise.
+ * gold.cc: Likewise.
+ * i386.cc: Likewise.
+ * icf.h: Likewise.
+ * incremental-dump.cc: Likewise.
+ * incremental.cc: Likewise.
+ * layout.cc: Likewise.
+ * layout.h: Likewise.
+ * main.cc: Likewise.
+ * merge.cc: Likewise.
+ * merge.h: Likewise.
+ * object.cc: Likewise.
+ * object.h: Likewise.
+ * options.cc: Likewise.
+ * options.h: Likewise.
+ * output.cc: Likewise.
+ * output.h: Likewise.
+ * plugin.cc: Likewise.
+ * plugin.h: Likewise.
+ * powerpc.cc: Likewise.
+ * reloc.cc: Likewise.
+ * script-c.h: Likewise.
+ * script-sections.cc: Likewise.
+ * script.cc: Likewise.
+ * stringpool.cc: Likewise.
+ * symtab.cc: Likewise.
+ * symtab.h: Likewise.
+ * target.cc: Likewise.
+ * timer.cc: Likewise.
+ * timer.h: Likewise.
+ * version.cc: Likewise.
+ * x86_64.cc: Likewise.
+
2010-08-24 Nick Clifton <nickc@redhat.com>
PR 11899
return NULL;
}
- Object *obj = make_elf_object((std::string(this->input_file_->filename())
+ Object* obj = make_elf_object((std::string(this->input_file_->filename())
+ "(" + member_name + ")"),
input_file, memoff, ehdr, read_size,
punconfigured);
std::map<off_t, Archive_member>::const_iterator p = this->members_.find(off);
if (p != this->members_.end())
{
- Object *obj = p->second.obj_;
+ Object* obj = p->second.obj_;
- Read_symbols_data *sd = p->second.sd_;
+ Read_symbols_data* sd = p->second.sd_;
if (mapfile != NULL)
mapfile->report_include_archive_member(obj->name(), sym, why);
if (input_objects->add_object(obj))
while (i < this->members_.size())
{
const Archive_member& member = this->members_[i];
- Object *obj = member.obj_;
+ Object* obj = member.obj_;
std::string why;
// Skip files with no symbols. Plugin objects have
// The directory search path.
Dirsearch* dirpath_;
// The task reading this archive.
- Task *task_;
+ Task* task_;
// Number of members in this archive;
unsigned int num_members_;
// True if we exclude this library archive from automatic export.
// For reading the files.
const Input_file_lib* lib_;
// The task reading this lib group.
- Task *task_;
+ Task* task_;
// Table of the objects in the group.
std::vector<Archive_member> members_;
};
Symbol_table* symtab_;
Layout* layout_;
Input_objects* input_objects_;
- Lib_group * lib_;
+ Lib_group* lib_;
Task_token* readsyms_blocker_;
Task_token* this_blocker_;
Task_token* next_blocker_;
// compilation time and generate a representation of it in PODs only. That
// way we can avoid initialization when the linker starts.
-Arm_reloc_property_table *arm_reloc_property_table = NULL;
+Arm_reloc_property_table* arm_reloc_property_table = NULL;
// Instruction template class. This class is similar to the insn_sequence
// struct in bfd/elf32-arm.c.
bool
section_needs_reloc_stub_scanning(const elfcpp::Shdr<32, big_endian>&,
const Relobj::Output_sections&,
- const Symbol_table *, const unsigned char*);
+ const Symbol_table*, const unsigned char*);
// Whether a section is a scannable text section.
bool
section_is_scannable(const elfcpp::Shdr<32, big_endian>&, unsigned int,
- const Output_section*, const Symbol_table *);
+ const Output_section*, const Symbol_table*);
// Whether a section needs to be scanned for the Cortex-A8 erratum.
bool
section_needs_cortex_a8_stub_scanning(const elfcpp::Shdr<32, big_endian>&,
unsigned int, Output_section*,
- const Symbol_table *);
+ const Symbol_table*);
// Scan a section for the Cortex-A8 erratum.
void
// Map platform-specific reloc types
static unsigned int
- get_real_reloc_type (unsigned int r_type);
+ get_real_reloc_type(unsigned int r_type);
//
// Methods to support stub-generations.
// reloc. This means the relocation type accesses a symbol not via
// GOT or PLT.
static inline bool
- reloc_is_non_pic (unsigned int r_type)
+ reloc_is_non_pic(unsigned int r_type)
{
switch (r_type)
{
// Handle ARM long branches.
static typename This::Status
arm_branch_common(unsigned int, const Relocate_info<32, big_endian>*,
- unsigned char *, const Sized_symbol<32>*,
+ unsigned char*, const Sized_symbol<32>*,
const Arm_relobj<big_endian>*, unsigned int,
const Symbol_value<32>*, Arm_address, Arm_address, bool);
// Handle THUMB long branches.
static typename This::Status
thumb_branch_common(unsigned int, const Relocate_info<32, big_endian>*,
- unsigned char *, const Sized_symbol<32>*,
+ unsigned char*, const Sized_symbol<32>*,
const Arm_relobj<big_endian>*, unsigned int,
const Symbol_value<32>*, Arm_address, Arm_address, bool);
// R_ARM_ABS8: S + A
static inline typename This::Status
- abs8(unsigned char *view,
+ abs8(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval)
{
// R_ARM_THM_ABS5: S + A
static inline typename This::Status
- thm_abs5(unsigned char *view,
+ thm_abs5(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval)
{
// R_ARM_ABS12: S + A
static inline typename This::Status
- abs12(unsigned char *view,
+ abs12(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval)
{
// R_ARM_ABS16: S + A
static inline typename This::Status
- abs16(unsigned char *view,
+ abs16(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval)
{
// R_ARM_ABS32: (S + A) | T
static inline typename This::Status
- abs32(unsigned char *view,
+ abs32(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address thumb_bit)
// R_ARM_REL32: (S + A) | T - P
static inline typename This::Status
- rel32(unsigned char *view,
+ rel32(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address address,
// R_ARM_THM_JUMP24: (S + A) | T - P
static typename This::Status
- thm_jump19(unsigned char *view, const Arm_relobj<big_endian>* object,
+ thm_jump19(unsigned char* view, const Arm_relobj<big_endian>* object,
const Symbol_value<32>* psymval, Arm_address address,
Arm_address thumb_bit);
// R_ARM_THM_JUMP6: S + A – P
static inline typename This::Status
- thm_jump6(unsigned char *view,
+ thm_jump6(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address address)
// R_ARM_THM_JUMP8: S + A – P
static inline typename This::Status
- thm_jump8(unsigned char *view,
+ thm_jump8(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address address)
// R_ARM_THM_JUMP11: S + A – P
static inline typename This::Status
- thm_jump11(unsigned char *view,
+ thm_jump11(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address address)
// R_ARM_GOT_PREL: GOT(S) + A - P
static inline typename This::Status
- got_prel(unsigned char *view,
+ got_prel(unsigned char* view,
Arm_address got_entry,
Arm_address address)
{
// R_ARM_PREL: (S + A) | T - P
static inline typename This::Status
- prel31(unsigned char *view,
+ prel31(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address address,
// R_ARM_THM_MOVW_BREL_NC: ((S + A) | T) - B(S)
// R_ARM_THM_MOVW_BREL: ((S + A) | T) - B(S)
static inline typename This::Status
- thm_movw(unsigned char *view,
+ thm_movw(unsigned char* view,
const Sized_relobj<32, big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address relative_address_base,
// R_ARM_V4BX
static inline typename This::Status
v4bx(const Relocate_info<32, big_endian>* relinfo,
- unsigned char *view,
+ unsigned char* view,
const Arm_relobj<big_endian>* object,
const Arm_address address,
const bool is_interworking)
Arm_relocate_functions<big_endian>::arm_branch_common(
unsigned int r_type,
const Relocate_info<32, big_endian>* relinfo,
- unsigned char *view,
+ unsigned char* view,
const Sized_symbol<32>* gsym,
const Arm_relobj<big_endian>* object,
unsigned int r_sym,
Arm_relocate_functions<big_endian>::thumb_branch_common(
unsigned int r_type,
const Relocate_info<32, big_endian>* relinfo,
- unsigned char *view,
+ unsigned char* view,
const Sized_symbol<32>* gsym,
const Arm_relobj<big_endian>* object,
unsigned int r_sym,
template<bool big_endian>
typename Arm_relocate_functions<big_endian>::Status
Arm_relocate_functions<big_endian>::thm_jump19(
- unsigned char *view,
+ unsigned char* view,
const Arm_relobj<big_endian>* object,
const Symbol_value<32>* psymval,
Arm_address address,
const elfcpp::Shdr<32, big_endian>& shdr,
unsigned int shndx,
const Output_section* os,
- const Symbol_table *symtab)
+ const Symbol_table* symtab)
{
// Skip any empty sections, unallocated sections or sections whose
// type are not SHT_PROGBITS.
Arm_relobj<big_endian>::section_needs_reloc_stub_scanning(
const elfcpp::Shdr<32, big_endian>& shdr,
const Relobj::Output_sections& out_sections,
- const Symbol_table *symtab,
+ const Symbol_table* symtab,
const unsigned char* pshdrs)
{
unsigned int sh_type = shdr.get_sh_type();
std::vector<unsigned int> deferred_exidx_sections;
const size_t shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
const unsigned char* pshdrs = sd->section_headers->data();
- const unsigned char *ps = pshdrs + shdr_size;
+ const unsigned char* ps = pshdrs + shdr_size;
bool must_merge_flags_and_attributes = false;
for (unsigned int i = 1; i < this->shnum(); ++i, ps += shdr_size)
{
// We read from the end because gas seems to put it near the end of
// the section headers.
const size_t shdr_size = elfcpp::Elf_sizes<32>::shdr_size;
- const unsigned char *ps =
+ const unsigned char* ps =
sd->section_headers->data() + shdr_size * (this->shnum() - 1);
for (unsigned int i = this->shnum(); i > 0; --i, ps -= shdr_size)
{
Target_arm<big_endian>::Relocate::relocate(
const Relocate_info<32, big_endian>* relinfo,
Target_arm* target,
- Output_section *output_section,
+ Output_section* output_section,
size_t relnum,
const elfcpp::Rel<32, big_endian>& rel,
unsigned int r_type,
//
template<bool big_endian>
unsigned int
-Target_arm<big_endian>::get_real_reloc_type (unsigned int r_type)
+Target_arm<big_endian>::get_real_reloc_type(unsigned int r_type)
{
switch (r_type)
{
Target_arm<big_endian>::get_secondary_compatible_arch(
const Attributes_section_data* pasd)
{
- const Object_attribute *known_attributes =
+ const Object_attribute* known_attributes =
pasd->known_attributes(Object_attribute::OBJ_ATTR_PROC);
// Note: the tag and its argument below are uleb128 values, though
Attributes_section_data* pasd,
int arch)
{
- Object_attribute *known_attributes =
+ Object_attribute* known_attributes =
pasd->known_attributes(Object_attribute::OBJ_ATTR_PROC);
if (arch == -1)
T(V7E_M), // V7E_M.
T(V4T_PLUS_V6_M) // V4T plus V6_M.
};
- static const int *comb[] =
+ static const int* comb[] =
{
v6t2,
v6k,
std::string
Target_arm<big_endian>::aeabi_enum_name(unsigned int value)
{
- static const char *aeabi_enum_names[] =
+ static const char* aeabi_enum_names[] =
{ "", "variable-size", "32-bit", "" };
const size_t aeabi_enum_names_size =
sizeof(aeabi_enum_names) / sizeof(aeabi_enum_names[0]);
std::string
Target_arm<big_endian>::tag_cpu_name_value(unsigned int value)
{
- static const char *name_table[] = {
+ static const char* name_table[] = {
// These aren't real CPU names, but we can't guess
// that from the architecture version alone.
"Pre v4",
if (!exidx_input_section->has_errors())
{
unsigned int text_shndx = exidx_input_section->link();
- Output_section *os = arm_relobj->output_section(text_shndx);
+ Output_section* os = arm_relobj->output_section(text_shndx);
if (os != NULL && (os->flags() & elfcpp::SHF_ALLOC) != 0)
sorted_output_sections.insert(os);
}
this->vendor_object_attributes_[vendor] =
new Vendor_object_attributes(vendor);
- const unsigned char *p = view;
+ const unsigned char* p = view;
p = view;
if (size > 0 && p != NULL && *(p++) == 'A')
{
section_size -= section_name_size + 4;
int vendor;
- const char *std_section = parameters->target().attributes_vendor();
+ const char* std_section = parameters->target().attributes_vendor();
if (std_section != NULL && strcmp(section_name, std_section) == 0)
vendor = Object_attribute::OBJ_ATTR_PROC;
else if (strcmp(section_name, "gnu") == 0)
// Determine what arguments an attribute tag takes.
static int
- arg_type (int vendor, int tag)
+ arg_type(int vendor, int tag)
{
switch (vendor)
{
// Determine whether a GNU object attribute tag takes an integer, a
// string or both. */
static int
- gnu_arg_type (int tag)
+ gnu_arg_type(int tag)
{
// Except for Tag_compatibility, for GNU attributes we follow the
// same rule ARM ones > 32 follow: odd-numbered tags take strings
gold_unreachable();
}
- Output_data_space *poc = new Output_data_space(addralign, ds_name);
- Output_section *os = layout->add_output_section_data(name,
+ Output_data_space* poc = new Output_data_space(addralign, ds_name);
+ Output_section* os = layout->add_output_section_data(name,
elfcpp::SHT_NOBITS,
flags, poc,
ORDER_INVALID,
Sized_symbol<size>* sym,
Sized_relobj<size, big_endian>* object,
unsigned int shndx,
- Output_section *output_section,
+ Output_section* output_section,
const Reloc& rel,
Output_data_reloc<sh_type, true, size, big_endian>* reloc_section)
{
// and that value plus one may be used to find the next file with
// the same name(s).
std::string
- find(const std::string&, const std::string& n2, bool *is_in_sysroot,
+ find(const std::string&, const std::string& n2, bool* is_in_sysroot,
int* pindex) const;
// Return the blocker token which controls access.
template<int size, bool big_endian>
void
Versions::need_section_contents(const Stringpool* dynpool,
- unsigned char** pp, unsigned int *psize,
- unsigned int *pentries) const
+ unsigned char** pp, unsigned int* psize,
+ unsigned int* pentries) const
{
gold_assert(this->is_finalized_);
gold_assert(!this->needs_.empty());
section_size_type symbol_names_size,
const unsigned char* pcontents,
const unsigned char* pcie,
- const unsigned char *pcieend,
+ const unsigned char* pcieend,
Track_relocs<size, big_endian>* relocs,
Offsets_to_cie* cies,
New_cies* new_cies)
const unsigned char* pcontents,
unsigned int offset,
const unsigned char* pfde,
- const unsigned char *pfdeend,
+ const unsigned char* pfdeend,
Track_relocs<size, big_endian>* relocs,
Offsets_to_cie* cies)
{
section_size_type symbol_names_size,
const unsigned char* pcontents,
const unsigned char* pcie,
- const unsigned char *pcieend,
+ const unsigned char* pcieend,
Track_relocs<size, big_endian>* relocs,
Offsets_to_cie* cies,
New_cies* new_cies);
const unsigned char* pcontents,
unsigned int offset,
const unsigned char* pfde,
- const unsigned char *pfdeend,
+ const unsigned char* pfdeend,
Track_relocs<size, big_endian>* relocs,
Offsets_to_cie* cies);
// This is a call to function FUNCTION_NAME. Print it. This is for
// debugging.
void
- print_function(FILE* f, const char *function_name) const
+ print_function(FILE* f, const char* function_name) const
{
fprintf(f, "%s(", function_name);
this->left_print(f);
// Open the file.
bool
-Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex)
+Input_file::open(const Dirsearch& dirpath, const Task* task, int* pindex)
{
std::string name;
if (!Input_file::find_file(dirpath, pindex, this->input_argument_,
// restarted to find the next file with a matching name by
// incrementing the result and calling this again.
bool
- open(const Dirsearch&, const Task*, int *pindex);
+ open(const Dirsearch&, const Task*, int* pindex);
// Return the name given by the user. For -lc this will return "c".
const char*
size_t local_count,
const unsigned char* plocal_syms)
{
- Object *dst_obj;
+ Object* dst_obj;
unsigned int dst_indx;
Scan scan;
gold_fatal(_("pthread_mutextattr_settype failed: %s"), strerror(err));
#endif
- err = pthread_mutex_init (&this->mutex_, &attr);
+ err = pthread_mutex_init(&this->mutex_, &attr);
if (err != 0)
gold_fatal(_("pthread_mutex_init failed: %s"), strerror(err));
++p)
{
// Update the value of output_section stored in rd.
- Read_relocs_data *rd = (*p)->get_relocs_data();
+ Read_relocs_data* rd = (*p)->get_relocs_data();
for (Read_relocs_data::Relocs_list::iterator q = rd->relocs.begin();
q != rd->relocs.end();
++q)
}
else
{
- Task_token *new_final_blocker = new Task_token(true);
+ Task_token* new_final_blocker = new Task_token(true);
new_final_blocker->add_blocker();
Task* t = new Write_after_input_sections_task(layout, of,
final_blocker,
inline bool
Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo,
Target_i386* target,
- Output_section *output_section,
+ Output_section* output_section,
size_t relnum,
const elfcpp::Rel<32, false>& rel,
unsigned int r_type,
// Given an object and a section index, this returns true if the
// pointer of the function defined in this section is taken.
bool
- section_has_function_pointers(Object *obj, unsigned int shndx)
+ section_has_function_pointers(Object* obj, unsigned int shndx)
{
return (this->fptr_section_id_.find(Section_id(obj, shndx))
!= this->fptr_section_id_.end());
// Records that a pointer of the function defined in this section
// is taken.
void
- set_section_has_function_pointers(Object *obj, unsigned int shndx)
+ set_section_has_function_pointers(Object* obj, unsigned int shndx)
{
this->fptr_section_id_.insert(Section_id(obj, shndx));
}
{
fprintf(stderr, "%s: %s: no .gnu_incremental_inputs section\n", argv0,
filename);
- exit (1);
+ exit(1);
}
elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file(inc);
if (symtab_shndx == elfcpp::SHN_UNDEF) // Not found.
{
fprintf(stderr, "%s: %s: no symbol table section\n", argv0, filename);
- exit (1);
+ exit(1);
}
Location symtab_location(elf_file.section_contents(symtab_shndx));
View symtab_view(inc->view(symtab_location));
|| elf_file.section_type(strtab_shndx) != elfcpp::SHT_STRTAB)
{
fprintf(stderr, "%s: %s: no string table section\n", argv0, filename);
- exit (1);
+ exit(1);
}
Location strtab_location(elf_file.section_contents(strtab_shndx));
View strtab_view(inc->view(strtab_location));
case INCREMENTAL_INPUT_OBJECT:
case INCREMENTAL_INPUT_ARCHIVE_MEMBER:
{
- Incremental_object_entry *entry = (*p)->object_entry();
+ Incremental_object_entry* entry = (*p)->object_entry();
gold_assert(entry != NULL);
(*p)->set_info_offset(info_offset);
// Input section count + global symbol count.
break;
case INCREMENTAL_INPUT_SHARED_LIBRARY:
{
- Incremental_object_entry *entry = (*p)->object_entry();
+ Incremental_object_entry* entry = (*p)->object_entry();
gold_assert(entry != NULL);
(*p)->set_info_offset(info_offset);
// Global symbol count.
break;
case INCREMENTAL_INPUT_ARCHIVE:
{
- Incremental_archive_entry *entry = (*p)->archive_entry();
+ Incremental_archive_entry* entry = (*p)->archive_entry();
gold_assert(entry != NULL);
(*p)->set_info_offset(info_offset);
// Member count + unused global symbol count.
std::string desc = std::string("gold ") + gold::get_version_string();
size_t trailing_padding;
- Output_section *os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
+ Output_section* os = this->create_note("GNU", elfcpp::NT_GNU_GOLD_VERSION,
".note.gnu.gold-version", desc.size(),
false, &trailing_padding);
if (os == NULL)
incr->create_data_sections(symtab);
// Add the .gnu_incremental_inputs section.
- const char *incremental_inputs_name =
+ const char* incremental_inputs_name =
this->namepool_.add(".gnu_incremental_inputs", false, NULL);
Output_section* incremental_inputs_os =
this->make_output_section(incremental_inputs_name,
incremental_inputs_os->add_output_section_data(incr->inputs_section());
// Add the .gnu_incremental_symtab section.
- const char *incremental_symtab_name =
+ const char* incremental_symtab_name =
this->namepool_.add(".gnu_incremental_symtab", false, NULL);
Output_section* incremental_symtab_os =
this->make_output_section(incremental_symtab_name,
incremental_symtab_os->set_entsize(4);
// Add the .gnu_incremental_relocs section.
- const char *incremental_relocs_name =
+ const char* incremental_relocs_name =
this->namepool_.add(".gnu_incremental_relocs", false, NULL);
Output_section* incremental_relocs_os =
this->make_output_section(incremental_relocs_name,
incremental_relocs_os->set_entsize(incr->relocs_entsize());
// Add the .gnu_incremental_got_plt section.
- const char *incremental_got_plt_name =
+ const char* incremental_got_plt_name =
this->namepool_.add(".gnu_incremental_got_plt", false, NULL);
Output_section* incremental_got_plt_os =
this->make_output_section(incremental_got_plt_name,
incremental_got_plt_os->add_output_section_data(incr->got_plt_section());
// Add the .gnu_incremental_strtab section.
- const char *incremental_strtab_name =
+ const char* incremental_strtab_name =
this->namepool_.add(".gnu_incremental_strtab", false, NULL);
Output_section* incremental_strtab_os = this->make_output_section(incremental_strtab_name,
elfcpp::SHT_STRTAB, 0,
off_t
Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
- unsigned int *pshndx)
+ unsigned int* pshndx)
{
// Sort them into the final order.
std::sort(this->segment_list_.begin(), this->segment_list_.end(),
off_t
Layout::set_relocatable_section_offsets(Output_data* file_header,
- unsigned int *pshndx)
+ unsigned int* pshndx)
{
off_t off = 0;
void
Layout::create_dynamic_symtab(const Input_objects* input_objects,
Symbol_table* symtab,
- Output_section **pdynstr,
+ Output_section** pdynstr,
unsigned int* plocal_dynamic_count,
std::vector<Symbol*>* pdynamic_symbols,
Versions* pversions)
if (is_compressed_debug_section(name))
{
size_t len = strlen(name);
- char *uncompressed_name = new char[len];
+ char* uncompressed_name = new char[len];
uncompressed_name[0] = '.';
gold_assert(name[0] == '.' && name[1] == 'z');
strncpy(&uncompressed_name[1], &name[2], len - 2);
// Look for a section name in the group list, and return whether it
// was found. If found, returns the section index and size.
bool
- find_comdat_section(const std::string& name, unsigned int *pshndx,
- uint64_t *psize) const
+ find_comdat_section(const std::string& name, unsigned int* pshndx,
+ uint64_t* psize) const
{
gold_assert(this->is_comdat_);
Comdat_group::const_iterator p = this->u_.group_sections->find(name);
// If there is only one section in the group list, return true, and
// return the section index and size.
bool
- find_single_comdat_section(unsigned int *pshndx, uint64_t *psize) const
+ find_single_comdat_section(unsigned int* pshndx, uint64_t* psize) const
{
gold_assert(this->is_comdat_);
if (this->u_.group_sections->size() != 1)
// Create a note section, filling in the header.
Output_section*
- create_note(const char* name, int note_type, const char *section_name,
+ create_note(const char* name, int note_type, const char* section_name,
size_t descsz, bool allocate, size_t* trailing_padding);
// Create a note section for gold version.
main(int argc, char** argv)
{
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
- setlocale (LC_MESSAGES, "");
+ setlocale(LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
- setlocale (LC_CTYPE, "");
+ setlocale(LC_CTYPE, "");
#endif
- bindtextdomain (PACKAGE, LOCALEDIR);
- textdomain (PACKAGE);
+ bindtextdomain(PACKAGE, LOCALEDIR);
+ textdomain(PACKAGE);
program_name = argv[0];
Object_merge_map::get_output_offset(const Merge_map* merge_map,
unsigned int shndx,
section_offset_type input_offset,
- section_offset_type *output_offset)
+ section_offset_type* output_offset)
{
Input_merge_map* map = this->get_input_merge_map(shndx);
if (map == NULL
bool
get_output_offset(const Merge_map*, unsigned int shndx,
section_offset_type offset,
- section_offset_type *output_offset);
+ section_offset_type* output_offset);
// Return whether this is the merge map for section SHNDX.
bool
bool
get_output_offset(const Relobj* object, unsigned int shndx,
section_offset_type offset,
- section_offset_type *output_offset) const;
+ section_offset_type* output_offset) const;
// Return whether this is the merge mapping for section SHNDX in
// OBJECT. This should return true when get_output_offset would
gold_assert(external_symbols_offset != 0);
unsigned int i = *p;
- const unsigned char *pshdr;
+ const unsigned char* pshdr;
pshdr = section_headers_data + i * This::shdr_size;
typename This::Shdr shdr(pshdr);
Address secoffset = out_offsets[shndx];
if (symtab->is_section_folded(this, shndx))
{
- gold_assert (os == NULL && secoffset == invalid_address);
+ gold_assert(os == NULL && secoffset == invalid_address);
// Get the os of the section it is folded onto.
Section_id folded = symtab->icf()->get_folded_section(this,
shndx);
Sized_relobj<size, big_endian>::do_section_entsize(unsigned int shndx)
{
Symbols_data* sd = this->get_symbols_data();
- gold_assert (sd != NULL);
+ gold_assert(sd != NULL);
const unsigned char* pshdrs = sd->section_headers_data
+ This::shdr_size * shndx;
bool
is_elf_object(Input_file* input_file, off_t offset,
- const unsigned char** start, int *read_size)
+ const unsigned char** start, int* read_size)
{
off_t filesize = input_file->file().filesize();
int want = elfcpp::Elf_recognizer::max_header_size;
// Decides which section names have to be included in the worklist
// as roots.
bool
- is_section_name_included(const char *name);
+ is_section_name_included(const char* name);
void
copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd,
// Used to store the symbols data computed by the Read_symbols pass.
// Again used during garbage collection when laying out referenced
// sections.
- gold::Symbols_data *sd_;
+ gold::Symbols_data* sd_;
// Per-symbol counts of relocations, for incremental links.
unsigned int* reloc_counts_;
// Per-symbol base indexes of relocations, for incremental links.
// Whether to include a section group in the link.
bool
include_section_group(Symbol_table*, Layout*, unsigned int, const char*,
- const unsigned char*, const char *, section_size_type,
+ const unsigned char*, const char*, section_size_type,
std::vector<bool>*);
// Whether to include a linkonce section in the link.
extern bool
is_elf_object(Input_file* input_file, off_t offset,
- const unsigned char** start, int *read_size);
+ const unsigned char** start, int* read_size);
// Return an Object appropriate for the input file. P is BYTES long,
// and holds the ELF header. If PUNCONFIGURED is not NULL, then if
}
void
-parse_uint64(const char* option_name, const char* arg, uint64_t *retval)
+parse_uint64(const char* option_name, const char* arg, uint64_t* retval)
{
char* endptr;
*retval = strtoull(arg, &endptr, 0);
Command_line* cmdline)
{
Input_file_argument::Input_file_type type;
- const char *name;
+ const char* name;
if (arg[0] == ':')
{
type = Input_file_argument::INPUT_FILE_TYPE_SEARCHED_FILE;
General_options::parse_exclude_libs(const char*, const char* arg,
Command_line*)
{
- const char *p = arg;
+ const char* p = arg;
while (*p != '\0')
{
// wild-card and matches any given name.
bool
-General_options::check_excluded_libs (const std::string &name) const
+General_options::check_excluded_libs(const std::string &name) const
{
Unordered_set<std::string>::const_iterator p;
return true;
// First strip off any directories in name.
- const char *basename = lbasename(name.c_str());
+ const char* basename = lbasename(name.c_str());
// Try finding an exact match.
p = excluded_libs_.find(std::string(basename));
}
void
-usage(const char* msg, const char *opt)
+usage(const char* msg, const char* opt)
{
fprintf(stderr,
_("%s: %s: %s\n"),
this->options_.finalize_dynamic_list();
Version_script_info* vsi = this->script_options_.version_script_info();
vsi->finalize();
- return *vsi;
+ return* vsi;
}
} // End namespace gold.
// Return true if S is the name of a library excluded from automatic
// symbol export.
bool
- check_excluded_libs (const std::string &s) const;
+ check_excluded_libs(const std::string &s) const;
// If an explicit start address was given for section SECNAME with
// the --section-start option, return true and set *PADDR to the
// Add a plugin and its arguments to the list of plugins.
void
- add_plugin(const char *filename);
+ add_plugin(const char* filename);
// Add a plugin option.
void
const Relobj* object,
unsigned int shndx,
section_offset_type offset,
- section_offset_type *poutput) const
+ section_offset_type* poutput) const
{
if (!this->is_input_section())
return this->u2_.posd->output_offset(object, shndx, offset, poutput);
Output_segment::write_section_headers(const Layout* layout,
const Stringpool* secnamepool,
unsigned char* v,
- unsigned int *pshndx) const
+ unsigned int* pshndx) const
{
// Every section that is attached to a segment must be attached to a
// PT_LOAD segment, so we only write out section headers for PT_LOAD
bool
output_offset(const Relobj* object, unsigned int shndx,
section_offset_type offset,
- section_offset_type *poutput) const
+ section_offset_type* poutput) const
{ return this->do_output_offset(object, shndx, offset, poutput); }
// Return whether this is the merge section for the input section
// Set the entry size and the link.
void
- do_adjust_output_section(Output_section *os);
+ do_adjust_output_section(Output_section* os);
// Write to a map file.
void
// Add a relocation entry.
void
- add(Output_data *od, const Output_reloc_type& reloc)
+ add(Output_data* od, const Output_reloc_type& reloc)
{
this->relocs_.push_back(reloc);
this->set_current_data_size(this->relocs_.size() * reloc_size);
template<int size, bool big_endian>
off_t
add_input_section(Layout* layout, Sized_relobj<size, big_endian>* object,
- unsigned int shndx, const char *name,
+ unsigned int shndx, const char* name,
const elfcpp::Shdr<size, big_endian>& shdr,
unsigned int reloc_shndx, bool have_sections_script);
}
// For a relaxed input section.
- Input_section(Output_relaxed_input_section *psection)
+ Input_section(Output_relaxed_input_section* psection)
: shndx_(RELAXED_INPUT_SECTION_CODE), p2align_(0),
section_order_index_(0)
{
set_output_section(Output_section* os)
{
gold_assert(!this->is_input_section());
- Output_section_data *posd =
+ Output_section_data* posd =
this->is_relaxed_input_section() ? this->u2_.poris : this->u2_.posd;
posd->set_output_section(os);
}
bool
output_offset(const Relobj* object, unsigned int shndx,
section_offset_type offset,
- section_offset_type *poutput) const;
+ section_offset_type* poutput) const;
// Return whether this is the merge section for the input section
// SHNDX in OBJECT.
// Allocate and populate a transfer vector.
const int tv_fixed_size = 16;
int tv_size = this->args_.size() + tv_fixed_size;
- ld_plugin_tv *tv = new ld_plugin_tv[tv_size];
+ ld_plugin_tv* tv = new ld_plugin_tv[tv_size];
// Put LDPT_MESSAGE at the front of the list so the plugin can use it
// while processing subsequent entries.
// Call the plugin claim-file handler.
inline bool
-Plugin::claim_file(struct ld_plugin_input_file *plugin_input_file)
+Plugin::claim_file(struct ld_plugin_input_file* plugin_input_file)
{
int claimed = 0;
ld_plugin_status
Plugin_manager::get_input_file(unsigned int handle,
- struct ld_plugin_input_file *file)
+ struct ld_plugin_input_file* file)
{
Pluginobj* obj = this->object(handle);
if (obj == NULL)
// Add a new library path.
ld_plugin_status
-Plugin_manager::set_extra_library_path(const char *path)
+Plugin_manager::set_extra_library_path(const char* path)
{
this->extra_search_path_ = std::string(path);
return LDPS_OK;
// Add a new input file.
ld_plugin_status
-Plugin_manager::add_input_file(const char *pathname, bool is_lib)
+Plugin_manager::add_input_file(const char* pathname, bool is_lib)
{
Input_file_argument file(pathname,
(is_lib
{
// We never decided to include this object. We mark all symbols as
// preempted.
- gold_assert (this->symbols_.size() == 0);
+ gold_assert(this->symbols_.size() == 0);
for (int i = 0; i < nsyms; i++)
syms[i].resolution = LDPR_PREEMPTED_REG;
return LDPS_OK;
for (int i = 0; i < this->nsyms_; ++i)
{
- const struct ld_plugin_symbol *isym = &this->syms_[i];
+ const struct ld_plugin_symbol* isym = &this->syms_[i];
const char* name = isym->name;
const char* ver = isym->version;
elfcpp::Elf_Half shndx;
// Add symbols from a plugin-claimed input file.
static enum ld_plugin_status
-add_symbols(void* handle, int nsyms, const ld_plugin_symbol *syms)
+add_symbols(void* handle, int nsyms, const ld_plugin_symbol* syms)
{
gold_assert(parameters->options().has_plugins());
Pluginobj* obj = parameters->options().plugins()->make_plugin_object(
// file descriptor.
static enum ld_plugin_status
-get_input_file(const void *handle, struct ld_plugin_input_file *file)
+get_input_file(const void* handle, struct ld_plugin_input_file* file)
{
gold_assert(parameters->options().has_plugins());
unsigned int obj_index =
// Release the input file.
static enum ld_plugin_status
-release_input_file(const void *handle)
+release_input_file(const void* handle)
{
gold_assert(parameters->options().has_plugins());
unsigned int obj_index =
// Get the symbol resolution info for a plugin-claimed input file.
static enum ld_plugin_status
-get_symbols(const void * handle, int nsyms, ld_plugin_symbol* syms)
+get_symbols(const void* handle, int nsyms, ld_plugin_symbol* syms)
{
gold_assert(parameters->options().has_plugins());
Pluginobj* obj = parameters->options().plugins()->object(
// Add a new (real) input file generated by a plugin.
static enum ld_plugin_status
-add_input_file(const char *pathname)
+add_input_file(const char* pathname)
{
gold_assert(parameters->options().has_plugins());
return parameters->options().plugins()->add_input_file(pathname, false);
// Add a new (real) library required by a plugin.
static enum ld_plugin_status
-add_input_library(const char *pathname)
+add_input_library(const char* pathname)
{
gold_assert(parameters->options().has_plugins());
return parameters->options().plugins()->add_input_file(pathname, true);
// add_input_library
static enum ld_plugin_status
-set_extra_library_path(const char *path)
+set_extra_library_path(const char* path)
{
gold_assert(parameters->options().has_plugins());
return parameters->options().plugins()->set_extra_library_path(path);
// Issue a diagnostic message from a plugin.
static enum ld_plugin_status
-message(int level, const char * format, ...)
+message(int level, const char* format, ...)
{
va_list args;
va_start(args, format);
// Call the claim-file handler.
bool
- claim_file(struct ld_plugin_input_file *plugin_input_file);
+ claim_file(struct ld_plugin_input_file* plugin_input_file);
// Call the all-symbols-read handler.
void
// Add an argument
void
- add_option(const char *arg)
+ add_option(const char* arg)
{
this->args_.push_back(arg);
}
// Call the plugin claim-file handlers in turn to see if any claim the file.
Pluginobj*
- claim_file(Input_file *input_file, off_t offset, off_t filesize);
+ claim_file(Input_file* input_file, off_t offset, off_t filesize);
// Call the all-symbols-read handlers.
void
// Get input file information with an open (possibly re-opened)
// file descriptor.
ld_plugin_status
- get_input_file(unsigned int handle, struct ld_plugin_input_file *file);
+ get_input_file(unsigned int handle, struct ld_plugin_input_file* file);
// Release an input file.
ld_plugin_status
// Add a new input file.
ld_plugin_status
- add_input_file(const char *pathname, bool is_lib);
+ add_input_file(const char* pathname, bool is_lib);
// Set the extra library path.
ld_plugin_status
- set_extra_library_path(const char *path);
+ set_extra_library_path(const char* path);
// Return TRUE if we are in the replacement phase.
bool
Output_data_space*
got2_section() const
{
- gold_assert (this->got2_ != NULL);
+ gold_assert(this->got2_ != NULL);
return this->got2_;
}
Output_data_space*
toc_section() const
{
- gold_assert (this->toc_ != NULL);
+ gold_assert(this->toc_ != NULL);
return this->toc_;
}
void
Read_relocs::run(Workqueue* workqueue)
{
- Read_relocs_data *rd = new Read_relocs_data;
+ Read_relocs_data* rd = new Read_relocs_data;
this->object_->read_relocs(rd);
this->object_->set_relocs_data(rd);
this->object_->release();
const Output_sections& out_sections(this->output_sections());
const std::vector<Address>& out_offsets(this->section_offsets_);
- const unsigned char *pshdrs = this->get_view(this->elf_file_.shoff(),
+ const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(),
shnum * This::shdr_size,
true, true);
// Skip the first, dummy, section.
- const unsigned char *ps = pshdrs + This::shdr_size;
+ const unsigned char* ps = pshdrs + This::shdr_size;
for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size)
{
typename This::Shdr shdr(ps);
script_register_vers_node(void* closure,
const char* tag,
int taglen,
- struct Version_tree *,
- struct Version_dependency_list *);
+ struct Version_tree*,
+ struct Version_dependency_list*);
-extern struct Version_dependency_list *
+extern struct Version_dependency_list*
script_add_vers_depend(void* closure,
- struct Version_dependency_list *existing_dependencies,
- const char *depend_to_add, int deplen);
+ struct Version_dependency_list* existing_dependencies,
+ const char* depend_to_add, int deplen);
-extern struct Version_expression_list *
+extern struct Version_expression_list*
script_new_vers_pattern(void* closure,
- struct Version_expression_list *,
- const char *, int, int);
+ struct Version_expression_list*,
+ const char*, int, int);
-extern struct Version_expression_list *
-script_merge_expressions(struct Version_expression_list *a,
- struct Version_expression_list *b);
+extern struct Version_expression_list*
+script_merge_expressions(struct Version_expression_list* a,
+ struct Version_expression_list* b);
-extern struct Version_tree *
+extern struct Version_tree*
script_new_vers_node(void* closure,
- struct Version_expression_list *global,
- struct Version_expression_list *local);
+ struct Version_expression_list* global,
+ struct Version_expression_list* local);
extern void
version_script_push_lang(void* closure, const char* lang, int langlen);
const char* file_name,
const char* section_name,
Output_section*** slot,
- Script_sections::Section_type *psection_type)
+ Script_sections::Section_type* psection_type)
{
// Ask each element whether it matches NAME.
for (Output_section_elements::const_iterator p = this->elements_.begin();
// Return the name of a script section type.
const char*
-Output_section_definition::script_section_type_name (
+Output_section_definition::script_section_type_name(
Script_section_type script_section_type)
{
switch (script_section_type)
Script_sections::start_output_section(
const char* name,
size_t namelen,
- const Parser_output_section_header *header)
+ const Parser_output_section_header* header)
{
Output_section_definition* posd = new Output_section_definition(name,
namelen,
const char* file_name,
const char* section_name,
Output_section*** output_section_slot,
- Script_sections::Section_type *psection_type)
+ Script_sections::Section_type* psection_type)
{
for (Sections_elements::const_iterator p = this->sections_elements_->begin();
p != this->sections_elements_->end();
p != this->sections_elements_->end();
++p)
{
- Output_section *os = (*p)->get_output_section();
+ Output_section* os = (*p)->get_output_section();
if (os != NULL && (os->flags() & elfcpp::SHF_TLS) != 0)
{
if (first_tls == NULL)
const char* (Lex::*can_continue_fn)(const char*),
const char* start,
const char* match,
- const char **pp)
+ const char** pp)
{
const char* new_match = NULL;
while ((new_match = (this->*can_continue_fn)(match)))
private:
// The symbol to demangle.
- const char *symbol_;
+ const char* symbol_;
// Option flags to pass to cplus_demagle.
const int options_;
// The cached demangled value, or NULL if demangling didn't happen yet or
// failed.
- char *demangled_;
+ char* demangled_;
// Whether we already called cplus_demangle
bool did_demangle_;
};
Version_script_info::add_exact_match(const std::string& match,
const Version_tree* v, bool is_global,
const Version_expression* ve,
- Exact *pe)
+ Exact* pe)
{
std::pair<Exact::iterator, bool> ins =
pe->insert(std::make_pair(match, Version_tree_match(v, is_global, ve)));
{
// In addition to checking the normal library search path, we
// also want to check in the script-directory.
- const char *slash = strrchr(closure->filename(), '/');
+ const char* slash = strrchr(closure->filename(), '/');
if (slash != NULL)
{
script_directory.assign(closure->filename(),
// Called by the bison parser to refer to a symbol.
extern "C" Expression*
-script_symbol(void *closurev, const char* name, size_t length)
+script_symbol(void* closurev, const char* name, size_t length)
{
Parser_closure* closure = static_cast<Parser_closure*>(closurev);
if (length != 1 || name[0] != '.')
script_register_vers_node(void*,
const char* tag,
int taglen,
- struct Version_tree *tree,
- struct Version_dependency_list *deps)
+ struct Version_tree* tree,
+ struct Version_dependency_list* deps)
{
gold_assert(tree != NULL);
tree->dependencies = deps;
// Add a dependencies to the list of existing dependencies, if any,
// and return the expanded list.
-extern "C" struct Version_dependency_list *
+extern "C" struct Version_dependency_list*
script_add_vers_depend(void* closurev,
- struct Version_dependency_list *all_deps,
- const char *depend_to_add, int deplen)
+ struct Version_dependency_list* all_deps,
+ const char* depend_to_add, int deplen)
{
Parser_closure* closure = static_cast<Parser_closure*>(closurev);
if (all_deps == NULL)
// Add a pattern expression to an existing list of expressions, if any.
-extern "C" struct Version_expression_list *
+extern "C" struct Version_expression_list*
script_new_vers_pattern(void* closurev,
- struct Version_expression_list *expressions,
- const char *pattern, int patlen, int exact_match)
+ struct Version_expression_list* expressions,
+ const char* pattern, int patlen, int exact_match)
{
Parser_closure* closure = static_cast<Parser_closure*>(closurev);
if (expressions == NULL)
// Attaches b to the end of a, and clears b. So a = a + b and b = {}.
extern "C" struct Version_expression_list*
-script_merge_expressions(struct Version_expression_list *a,
- struct Version_expression_list *b)
+script_merge_expressions(struct Version_expression_list* a,
+ struct Version_expression_list* b)
{
a->expressions.insert(a->expressions.end(),
b->expressions.begin(), b->expressions.end());
// Combine the global and local expressions into a a Version_tree.
-extern "C" struct Version_tree *
+extern "C" struct Version_tree*
script_new_vers_node(void* closurev,
- struct Version_expression_list *global,
- struct Version_expression_list *local)
+ struct Version_expression_list* global,
+ struct Version_expression_list* local)
{
Parser_closure* closure = static_cast<Parser_closure*>(closurev);
Version_tree* tree = closure->version_script()->allocate_version_tree();
alc = sizeof(Stringdata) + buffer_size;
else
{
- Stringdata *psd = this->strings_.front();
+ Stringdata* psd = this->strings_.front();
if (len > psd->alc - psd->len)
alc = sizeof(Stringdata) + buffer_size;
else
}
}
- Stringdata *psd = reinterpret_cast<Stringdata*>(new char[alc]);
+ Stringdata* psd = reinterpret_cast<Stringdata*>(new char[alc]);
psd->alc = alc - sizeof(Stringdata);
memcpy(psd->data, s, len - sizeof(Stringpool_char));
memset(psd->data + len - sizeof(Stringpool_char), 0,
{
const char* name = p->c_str();
Symbol* sym = this->lookup(name);
- gold_assert (sym != NULL);
+ gold_assert(sym != NULL);
if (sym->source() == Symbol::FROM_OBJECT
&& !sym->object()->is_dynamic())
{
if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
&& !sym->object()->is_dynamic())
{
- Relobj *obj = static_cast<Relobj*>(sym->object());
+ Relobj* obj = static_cast<Relobj*>(sym->object());
bool is_ordinary;
unsigned int shndx = sym->shndx(&is_ordinary);
if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
template<int size, bool big_endian>
Sized_symbol<size>*
Symbol_table::add_from_object(Object* object,
- const char *name,
+ const char* name,
Stringpool::Key name_key,
- const char *version,
+ const char* version,
Stringpool::Key version_key,
bool is_default_version,
const elfcpp::Sym<size, big_endian>& sym,
const char* sym_names,
size_t sym_name_size,
typename Sized_relobj<size, big_endian>::Symbols* sympointers,
- size_t *defined)
+ size_t* defined)
{
*defined = 0;
Symbol_table::define_special_symbol(const char** pname, const char** pversion,
bool only_if_ref,
Sized_symbol<size>** poldsym,
- bool *resolve_oldsym)
+ bool* resolve_oldsym)
{
*resolve_oldsym = false;
off_t
Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
size_t dyncount, Stringpool* pool,
- unsigned int *plocal_symcount)
+ unsigned int* plocal_symcount)
{
off_t ret;
// Write out a section symbol. Return the update offset.
void
-Symbol_table::write_section_symbol(const Output_section *os,
+Symbol_table::write_section_symbol(const Output_section* os,
Output_symtab_xindex* symtab_xindex,
Output_file* of,
off_t offset) const
// index rather than a special code.
template<int size, bool big_endian>
void
- init_base_object(const char *name, const char* version, Object* object,
+ init_base_object(const char* name, const char* version, Object* object,
const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
bool is_ordinary);
// index rather than a special code.
template<bool big_endian>
void
- init_object(const char *name, const char* version, Object* object,
+ init_object(const char* name, const char* version, Object* object,
const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
bool is_ordinary);
// local symbols.
off_t
finalize(off_t off, off_t dynoff, size_t dyn_global_index, size_t dyncount,
- Stringpool* pool, unsigned int *plocal_symcount);
+ Stringpool* pool, unsigned int* plocal_symcount);
// Status code of Symbol_table::compute_final_value.
enum Compute_final_value_status
// Add a symbol.
template<int size, bool big_endian>
Sized_symbol<size>*
- add_from_object(Object*, const char *name, Stringpool::Key name_key,
- const char *version, Stringpool::Key version_key,
+ add_from_object(Object*, const char* name, Stringpool::Key name_key,
+ const char* version, Stringpool::Key version_key,
bool def, const elfcpp::Sym<size, big_endian>& sym,
unsigned int st_shndx, bool is_ordinary,
unsigned int orig_st_shndx);
// in _bfd_elf_is_local_label_name().
bool
-Target::do_is_local_label_name (const char* name) const
+Target::do_is_local_label_name(const char* name) const
{
// Normal local symbols start with ``.L''.
if (name[0] == '.' && name[1] == 'L')
// Start couting the time.
void
-Timer::start ()
+Timer::start()
{
this->get_time(&this->start_time_);
}
// Write the current time infortamion.
void
-Timer::get_time (TimeStats *now)
+Timer::get_time(TimeStats *now)
{
#ifdef HAVE_TIMES
tms t;
// Return the stats since start was called.
Timer::TimeStats
-Timer::get_elapsed_time ()
+Timer::get_elapsed_time()
{
TimeStats now;
this->get_time(&now);
// Write the current time infortamion.
static void
- get_time(TimeStats *now);
+ get_time(TimeStats* now);
// The time of the last call to start.
TimeStats start_time_;
if (!print_short)
{
// This output is intended to follow the GNU standards.
- printf (_("Copyright 2010 Free Software Foundation, Inc.\n"));
- printf (_("\
+ printf(_("Copyright 2010 Free Software Foundation, Inc.\n"));
+ printf(_("\
This program is free software; you may redistribute it under the terms of\n\
the GNU General Public License version 3 or (at your option) a later version.\n\
This program has absolutely no warranty.\n"));
// we handle the SHF_X86_64_LARGE.
void
-Target_x86_64::do_new_output_section(Output_section *os) const
+Target_x86_64::do_new_output_section(Output_section* os) const
{
if ((os->flags() & elfcpp::SHF_X86_64_LARGE) != 0)
os->set_is_large_section();
// the section has been created.
target->got_section(symtab, layout);
Output_data_got<64, false>* got = target->got_tlsdesc_section();
- Reloc_section *rt = target->rela_tlsdesc_section(layout);
+ Reloc_section* rt = target->rela_tlsdesc_section(layout);
got->add_global_pair_with_rela(gsym, GOT_TYPE_TLS_DESC, rt,
elfcpp::R_X86_64_TLSDESC, 0);
}
projects / binutils-gdb.git / commitdiff