diff options
| author | Ian Lance Taylor <ian@airs.com> | 2009-12-14 19:53:05 +0000 |
|---|---|---|
| committer | Ian Lance Taylor <ian@airs.com> | 2009-12-14 19:53:05 +0000 |
| commit | 2ea97941102380c28117882600265c1187c6fc8b (patch) | |
| tree | 8f423876f9f118fbe6f7959e60984cd13ad7430d /gold | |
| parent | ab8e2090b6435823d50b29b7a255140ba6ea673f (diff) | |
| download | fsf-binutils-gdb-2ea97941102380c28117882600265c1187c6fc8b.zip fsf-binutils-gdb-2ea97941102380c28117882600265c1187c6fc8b.tar.gz fsf-binutils-gdb-2ea97941102380c28117882600265c1187c6fc8b.tar.bz2 | |
Revert -Wshadow changes, all changes from:
2009-12-11 Doug Kwan <dougkwan@google.com>
2009-12-11 Nick Clifton <nickc@redhat.com>
* configure.ac: Remove -Wshadow when setting WARN_CXXFLAGS.
Diffstat (limited to 'gold')
53 files changed, 1778 insertions, 1768 deletions
diff --git a/gold/ChangeLog b/gold/ChangeLog index a4ed9e8..03e03ae 100644 --- a/gold/ChangeLog +++ b/gold/ChangeLog @@ -1,3 +1,10 @@ +2009-12-14 Ian Lance Taylor <iant@google.com> + + Revert -Wshadow changes, all changes from: + 2009-12-11 Doug Kwan <dougkwan@google.com> + 2009-12-11 Nick Clifton <nickc@redhat.com> + * configure.ac: Remove -Wshadow when setting WARN_CXXFLAGS. + 2009-12-11 Doug Kwan <dougkwan@google.com> * arm.cc (Target_arm::do_finalize_sections): Fix build breakage diff --git a/gold/archive.cc b/gold/archive.cc index 7c82ca0..569a491 100644 --- a/gold/archive.cc +++ b/gold/archive.cc @@ -83,15 +83,15 @@ const char Archive::armagt[sarmag] = const char Archive::arfmag[2] = { '`', '\n' }; -Archive::Archive(const std::string& aname, Input_file* ainput_file, - bool is_a_thin_archive, Dirsearch* dirpath, Task* task) - : name_(aname), input_file_(ainput_file), armap_(), armap_names_(), +Archive::Archive(const std::string& name, Input_file* input_file, + bool is_thin_archive, Dirsearch* dirpath, Task* task) + : name_(name), input_file_(input_file), armap_(), armap_names_(), extended_names_(), armap_checked_(), seen_offsets_(), members_(), - is_thin_archive_(is_a_thin_archive), included_member_(false), + is_thin_archive_(is_thin_archive), included_member_(false), nested_archives_(), dirpath_(dirpath), task_(task), num_members_(0) { this->no_export_ = - parameters->options().check_excluded_libs(ainput_file->found_name()); + parameters->options().check_excluded_libs(input_file->found_name()); } // Set up the archive: read the symbol map and the extended name @@ -247,9 +247,9 @@ Archive::interpret_header(const Archive_header* hdr, off_t off, *ps = '\0'; errno = 0; - char* hend; - off_t member_size = strtol(size_string, &hend, 10); - if (*hend != '\0' + char* end; + off_t member_size = strtol(size_string, &end, 10); + if (*end != '\0' || member_size < 0 || (member_size == LONG_MAX && errno == ERANGE)) { @@ -285,11 +285,11 @@ Archive::interpret_header(const Archive_header* hdr, off_t off, else { errno = 0; - long x = strtol(hdr->ar_name + 1, &hend, 10); + long x = strtol(hdr->ar_name + 1, &end, 10); long y = 0; - if (*hend == ':') - y = strtol(hend + 1, &hend, 10); - if (*hend != ' ' + if (*end == ':') + y = strtol(end + 1, &end, 10); + if (*end != ' ' || x < 0 || (x == LONG_MAX && errno == ERANGE) || static_cast<size_t>(x) >= this->extended_names_.size()) @@ -299,16 +299,16 @@ Archive::interpret_header(const Archive_header* hdr, off_t off, return this->input_file_->file().filesize() - off; } - const char* name_start = this->extended_names_.data() + x; - const char* name_end = strchr(name_start, '\n'); - if (static_cast<size_t>(name_end - name_start) > this->extended_names_.size() + const char* name = this->extended_names_.data() + x; + const char* name_end = strchr(name, '\n'); + if (static_cast<size_t>(name_end - name) > this->extended_names_.size() || name_end[-1] != '/') { gold_error(_("%s: bad extended name entry at header %zu"), this->name().c_str(), static_cast<size_t>(off)); return this->input_file_->file().filesize() - off; } - pname->assign(name_start, name_end - 1 - name_start); + pname->assign(name, name_end - 1 - name); if (nested_off != NULL) *nested_off = y; } @@ -452,14 +452,14 @@ Archive::end() // to the name of the archive member. Return TRUE on success. bool -Archive::get_file_and_offset(off_t off, Input_file** in_file, off_t* memoff, +Archive::get_file_and_offset(off_t off, Input_file** input_file, off_t* memoff, off_t* memsize, std::string* member_name) { off_t nested_off; *memsize = this->read_header(off, false, member_name, &nested_off); - *in_file = this->input_file_; + *input_file = this->input_file_; *memoff = off + static_cast<off_t>(sizeof(Archive_header)); if (!this->is_thin_archive_) @@ -492,18 +492,18 @@ Archive::get_file_and_offset(off_t off, Input_file** in_file, off_t* memoff, new Input_file_argument(member_name->c_str(), Input_file_argument::INPUT_FILE_TYPE_FILE, "", false, parameters->options()); - *in_file = new Input_file(input_file_arg); + *input_file = new Input_file(input_file_arg); int dummy = 0; - if (!(*in_file)->open(*this->dirpath_, this->task_, &dummy)) + if (!(*input_file)->open(*this->dirpath_, this->task_, &dummy)) return false; - arch = new Archive(*member_name, *in_file, false, this->dirpath_, + arch = new Archive(*member_name, *input_file, false, this->dirpath_, this->task_); arch->setup(); std::pair<Nested_archive_table::iterator, bool> ins = this->nested_archives_.insert(std::make_pair(*member_name, arch)); gold_assert(ins.second); } - return arch->get_file_and_offset(nested_off, in_file, memoff, + return arch->get_file_and_offset(nested_off, input_file, memoff, memsize, member_name); } @@ -513,13 +513,13 @@ Archive::get_file_and_offset(off_t off, Input_file** in_file, off_t* memoff, new Input_file_argument(member_name->c_str(), Input_file_argument::INPUT_FILE_TYPE_FILE, "", false, this->input_file_->options()); - *in_file = new Input_file(input_file_arg); + *input_file = new Input_file(input_file_arg); int dummy = 0; - if (!(*in_file)->open(*this->dirpath_, this->task_, &dummy)) + if (!(*input_file)->open(*this->dirpath_, this->task_, &dummy)) return false; *memoff = 0; - *memsize = (*in_file)->file().filesize(); + *memsize = (*input_file)->file().filesize(); return true; } @@ -532,17 +532,17 @@ Archive::get_elf_object_for_member(off_t off, bool* punconfigured) { *punconfigured = false; - Input_file* in_file; + Input_file* input_file; off_t memoff; off_t memsize; std::string member_name; - if (!this->get_file_and_offset(off, &in_file, &memoff, &memsize, + if (!this->get_file_and_offset(off, &input_file, &memoff, &memsize, &member_name)) return NULL; if (parameters->options().has_plugins()) { - Object* obj = parameters->options().plugins()->claim_file(in_file, + Object* obj = parameters->options().plugins()->claim_file(input_file, memoff, memsize); if (obj != NULL) @@ -555,7 +555,7 @@ Archive::get_elf_object_for_member(off_t off, bool* punconfigured) const unsigned char* ehdr; int read_size; - if (!is_elf_object(in_file, memoff, &ehdr, &read_size)) + if (!is_elf_object(input_file, memoff, &ehdr, &read_size)) { gold_error(_("%s: member at %zu is not an ELF object"), this->name().c_str(), static_cast<size_t>(off)); @@ -564,7 +564,7 @@ Archive::get_elf_object_for_member(off_t off, bool* punconfigured) Object *obj = make_elf_object((std::string(this->input_file_->filename()) + "(" + member_name + ")"), - in_file, memoff, ehdr, read_size, + input_file, memoff, ehdr, read_size, punconfigured); if (obj == NULL) return NULL; diff --git a/gold/arm.cc b/gold/arm.cc index 5faaf3c..03cc697 100644 --- a/gold/arm.cc +++ b/gold/arm.cc @@ -210,8 +210,8 @@ class Insn_template // We make the constructor private to ensure that only the factory // methods are used. inline - Insn_template(unsigned adata, Type atype, unsigned int rtype, int relocaddend) - : data_(adata), type_(atype), r_type_(rtype), reloc_addend_(relocaddend) + Insn_template(unsigned data, Type type, unsigned int r_type, int reloc_addend) + : data_(data), type_(type), r_type_(r_type), reloc_addend_(reloc_addend) { } // Instruction specific data. This is used to store information like @@ -373,8 +373,8 @@ class Stub static_cast<section_offset_type>(-1); public: - Stub(const Stub_template* stubtemplate) - : stub_template_(stubtemplate), offset_(invalid_offset) + Stub(const Stub_template* stub_template) + : stub_template_(stub_template), offset_(invalid_offset) { } virtual @@ -396,8 +396,8 @@ class Stub // Set offset of code stub from beginning of its containing stub table. void - set_offset(section_offset_type off) - { this->offset_ = off; } + set_offset(section_offset_type offset) + { this->offset_ = offset; } // Return the relocation target address of the i-th relocation in the // stub. This must be defined in a child class. @@ -475,20 +475,20 @@ class Reloc_stub : public Stub // If SYMBOL is not null, this is a global symbol, we ignore RELOBJ and // R_SYM. Otherwise, this is a local symbol and RELOBJ must non-NULL // and R_SYM must not be invalid_index. - Key(Stub_type stubtype, const Symbol* sym, const Relobj* rel_obj, - unsigned int rsym, int32_t addend) - : stub_type_(stubtype), addend_(addend) + Key(Stub_type stub_type, const Symbol* symbol, const Relobj* relobj, + unsigned int r_sym, int32_t addend) + : stub_type_(stub_type), addend_(addend) { - if (sym != NULL) + if (symbol != NULL) { this->r_sym_ = Reloc_stub::invalid_index; - this->u_.symbol = sym; + this->u_.symbol = symbol; } else { - gold_assert(rel_obj != NULL && rsym != invalid_index); - this->r_sym_ = rsym; - this->u_.relobj = rel_obj; + gold_assert(relobj != NULL && r_sym != invalid_index); + this->r_sym_ = r_sym; + this->u_.relobj = relobj; } } @@ -585,8 +585,8 @@ class Reloc_stub : public Stub protected: // Reloc_stubs are created via a stub factory. So these are protected. - Reloc_stub(const Stub_template* stubtemplate) - : Stub(stubtemplate), destination_address_(invalid_address) + Reloc_stub(const Stub_template* stub_template) + : Stub(stub_template), destination_address_(invalid_address) { } ~Reloc_stub() @@ -660,8 +660,8 @@ template<bool big_endian> class Stub_table : public Output_data { public: - Stub_table(Arm_input_section<big_endian>* own) - : Output_data(), addralign_(1), owner_(own), has_been_changed_(false), + Stub_table(Arm_input_section<big_endian>* owner) + : Output_data(), addralign_(1), owner_(owner), has_been_changed_(false), reloc_stubs_() { } @@ -755,8 +755,8 @@ template<bool big_endian> class Arm_input_section : public Output_relaxed_input_section { public: - Arm_input_section(Relobj* rel_obj, unsigned int sec_shndx) - : Output_relaxed_input_section(rel_obj, sec_shndx, 1), + Arm_input_section(Relobj* relobj, unsigned int shndx) + : Output_relaxed_input_section(relobj, shndx, 1), original_addralign_(1), original_size_(0), stub_table_(NULL) { } @@ -779,8 +779,8 @@ class Arm_input_section : public Output_relaxed_input_section // Set the stub_table. void - set_stub_table(Stub_table<big_endian>* stubtable) - { this->stub_table_ = stubtable; } + set_stub_table(Stub_table<big_endian>* stub_table) + { this->stub_table_ = stub_table; } // Downcast a base pointer to an Arm_input_section pointer. This is // not type-safe but we only use Arm_input_section not the base class. @@ -814,17 +814,17 @@ class Arm_input_section : public Output_relaxed_input_section // Output offset. bool - do_output_offset(const Relobj* object, unsigned int sec_shndx, - section_offset_type off, + do_output_offset(const Relobj* object, unsigned int shndx, + section_offset_type offset, section_offset_type* poutput) const { if ((object == this->relobj()) - && (sec_shndx == this->shndx()) - && (off >= 0) - && (convert_types<uint64_t, section_offset_type>(off) + && (shndx == this->shndx()) + && (offset >= 0) + && (convert_types<uint64_t, section_offset_type>(offset) <= this->original_size_)) { - *poutput = off; + *poutput = offset; return true; } else @@ -851,9 +851,9 @@ template<bool big_endian> class Arm_output_section : public Output_section { public: - Arm_output_section(const char* aname, elfcpp::Elf_Word atype, - elfcpp::Elf_Xword xflags) - : Output_section(aname, atype, xflags) + Arm_output_section(const char* name, elfcpp::Elf_Word type, + elfcpp::Elf_Xword flags) + : Output_section(name, type, flags) { } ~Arm_output_section() @@ -890,9 +890,9 @@ class Arm_relobj : public Sized_relobj<32, big_endian> public: static const Arm_address invalid_address = static_cast<Arm_address>(-1); - Arm_relobj(const std::string& aname, Input_file* inputfile, off_t off, + Arm_relobj(const std::string& name, Input_file* input_file, off_t offset, const typename elfcpp::Ehdr<32, big_endian>& ehdr) - : Sized_relobj<32, big_endian>(aname, inputfile, off, ehdr), + : Sized_relobj<32, big_endian>(name, input_file, offset, ehdr), stub_tables_(), local_symbol_is_thumb_function_(), attributes_section_data_(NULL) { } @@ -902,18 +902,18 @@ class Arm_relobj : public Sized_relobj<32, big_endian> // Return the stub table of the SHNDX-th section if there is one. Stub_table<big_endian>* - stub_table(unsigned int sec_shndx) const + stub_table(unsigned int shndx) const { - gold_assert(sec_shndx < this->stub_tables_.size()); - return this->stub_tables_[sec_shndx]; + gold_assert(shndx < this->stub_tables_.size()); + return this->stub_tables_[shndx]; } // Set STUB_TABLE to be the stub_table of the SHNDX-th section. void - set_stub_table(unsigned int sec_shndx, Stub_table<big_endian>* stubtable) + set_stub_table(unsigned int shndx, Stub_table<big_endian>* stub_table) { - gold_assert(sec_shndx < this->stub_tables_.size()); - this->stub_tables_[sec_shndx] = stubtable; + gold_assert(shndx < this->stub_tables_.size()); + this->stub_tables_[shndx] = stub_table; } // Whether a local symbol is a THUMB function. R_SYM is the symbol table @@ -932,19 +932,19 @@ class Arm_relobj : public Sized_relobj<32, big_endian> // Convert regular input section with index SHNDX to a relaxed section. void - convert_input_section_to_relaxed_section(unsigned sec_shndx) + convert_input_section_to_relaxed_section(unsigned shndx) { // The stubs have relocations and we need to process them after writing // out the stubs. So relocation now must follow section write. - this->invalidate_section_offset(sec_shndx); + this->invalidate_section_offset(shndx); this->set_relocs_must_follow_section_writes(); } // Downcast a base pointer to an Arm_relobj pointer. This is // not type-safe but we only use Arm_relobj not the base class. static Arm_relobj<big_endian>* - as_arm_relobj(Relobj* rel_obj) - { return static_cast<Arm_relobj<big_endian>*>(rel_obj); } + as_arm_relobj(Relobj* relobj) + { return static_cast<Arm_relobj<big_endian>*>(relobj); } // Processor-specific flags in ELF file header. This is valid only after // reading symbols. @@ -1004,10 +1004,10 @@ template<bool big_endian> class Arm_dynobj : public Sized_dynobj<32, big_endian> { public: - Arm_dynobj(const std::string& aname, Input_file* inputfile, off_t off, + Arm_dynobj(const std::string& name, Input_file* input_file, off_t offset, const elfcpp::Ehdr<32, big_endian>& ehdr) - : Sized_dynobj<32, big_endian>(aname, inputfile, off, ehdr), - processor_specific_flags_(0) + : Sized_dynobj<32, big_endian>(name, input_file, offset, ehdr), + processor_specific_flags_(0), attributes_section_data_(NULL) { } ~Arm_dynobj() @@ -1347,7 +1347,7 @@ class Target_arm : public Sized_target<32, big_endian> // Find the Arm_input_section object corresponding to the SHNDX-th input // section of RELOBJ. Arm_input_section<big_endian>* - find_arm_input_section(Relobj* rel_obj, unsigned int sec_shndx) const; + find_arm_input_section(Relobj* relobj, unsigned int shndx) const; // Make a new Stub_table Stub_table<big_endian>* @@ -1600,12 +1600,12 @@ class Target_arm : public Sized_target<32, big_endian> void copy_reloc(Symbol_table* symtab, Layout* layout, Sized_relobj<32, big_endian>* object, - unsigned int sec_shndx, Output_section* output_section, + unsigned int shndx, Output_section* output_section, Symbol* sym, const elfcpp::Rel<32, big_endian>& reloc) { this->copy_relocs_.copy_reloc(symtab, layout, symtab->get_sized_symbol<32>(sym), - object, sec_shndx, output_section, reloc, + object, shndx, output_section, reloc, this->rel_dyn_section(layout)); } @@ -2369,15 +2369,15 @@ Arm_relocate_functions<big_endian>::arm_branch_common( (thumb_bit != 0)); if (stub_type != arm_stub_none) { - Stub_table<big_endian>* stubtable = + Stub_table<big_endian>* stub_table = object->stub_table(relinfo->data_shndx); - gold_assert(stubtable != NULL); + gold_assert(stub_table != NULL); Reloc_stub::Key stub_key(stub_type, gsym, object, r_sym, addend); - stub = stubtable->find_reloc_stub(stub_key); + stub = stub_table->find_reloc_stub(stub_key); gold_assert(stub != NULL); thumb_bit = stub->stub_template()->entry_in_thumb_mode() ? 1 : 0; - branch_target = stubtable->address() + stub->offset() + addend; + branch_target = stub_table->address() + stub->offset() + addend; branch_offset = branch_target - address; gold_assert((branch_offset <= ARM_MAX_FWD_BRANCH_OFFSET) && (branch_offset >= ARM_MAX_BWD_BRANCH_OFFSET)); @@ -2516,15 +2516,15 @@ Arm_relocate_functions<big_endian>::thumb_branch_common( (thumb_bit != 0)); if (stub_type != arm_stub_none) { - Stub_table<big_endian>* stubtable = + Stub_table<big_endian>* stub_table = object->stub_table(relinfo->data_shndx); - gold_assert(stubtable != NULL); + gold_assert(stub_table != NULL); Reloc_stub::Key stub_key(stub_type, gsym, object, r_sym, addend); - Reloc_stub* stub = stubtable->find_reloc_stub(stub_key); + Reloc_stub* stub = stub_table->find_reloc_stub(stub_key); gold_assert(stub != NULL); thumb_bit = stub->stub_template()->entry_in_thumb_mode() ? 1 : 0; - branch_target = stubtable->address() + stub->offset() + addend; + branch_target = stub_table->address() + stub->offset() + addend; branch_offset = branch_target - address; } } @@ -2677,21 +2677,21 @@ Insn_template::alignment() const // Stub_template methods. Stub_template::Stub_template( - Stub_type atype, const Insn_template* iinsns, - size_t insncount) - : type_(atype), insns_(iinsns), insn_count_(insncount), alignment_(1), + Stub_type type, const Insn_template* insns, + size_t insn_count) + : type_(type), insns_(insns), insn_count_(insn_count), alignment_(1), entry_in_thumb_mode_(false), relocs_() { - off_t off = 0; + off_t offset = 0; // Compute byte size and alignment of stub template. - for (size_t i = 0; i < insncount; i++) + for (size_t i = 0; i < insn_count; i++) { - unsigned insn_alignment = iinsns[i].alignment(); - size_t insn_size = iinsns[i].size(); - gold_assert((off & (insn_alignment - 1)) == 0); + unsigned insn_alignment = insns[i].alignment(); + size_t insn_size = insns[i].size(); + gold_assert((offset & (insn_alignment - 1)) == 0); this->alignment_ = std::max(this->alignment_, insn_alignment); - switch (iinsns[i].type()) + switch (insns[i].type()) { case Insn_template::THUMB16_TYPE: if (i == 0) @@ -2699,8 +2699,8 @@ Stub_template::Stub_template( break; case Insn_template::THUMB32_TYPE: - if (iinsns[i].r_type() != elfcpp::R_ARM_NONE) - this->relocs_.push_back(Reloc(i, off)); + if (insns[i].r_type() != elfcpp::R_ARM_NONE) + this->relocs_.push_back(Reloc(i, offset)); if (i == 0) this->entry_in_thumb_mode_ = true; break; @@ -2708,22 +2708,22 @@ Stub_template::Stub_template( case Insn_template::ARM_TYPE: // Handle cases where the target is encoded within the // instruction. - if (iinsns[i].r_type() == elfcpp::R_ARM_JUMP24) - this->relocs_.push_back(Reloc(i, off)); + if (insns[i].r_type() == elfcpp::R_ARM_JUMP24) + this->relocs_.push_back(Reloc(i, offset)); break; case Insn_template::DATA_TYPE: // Entry point cannot be data. gold_assert(i != 0); - this->relocs_.push_back(Reloc(i, off)); + this->relocs_.push_back(Reloc(i, offset)); break; default: gold_unreachable(); } - off += insn_size; + offset += insn_size; } - this->size_ = off; + this->size_ = offset; } // Reloc_stub::Key methods. @@ -2939,12 +2939,12 @@ void inline Reloc_stub::do_fixed_endian_write(unsigned char* view, section_size_type view_size) { - const Stub_template* stubtemplate = this->stub_template(); - const Insn_template* insns = stubtemplate->insns(); + const Stub_template* stub_template = this->stub_template(); + const Insn_template* insns = stub_template->insns(); // FIXME: We do not handle BE8 encoding yet. unsigned char* pov = view; - for (size_t i = 0; i < stubtemplate->insn_count(); i++) + for (size_t i = 0; i < stub_template->insn_count(); i++) { switch (insns[i].type()) { @@ -3198,11 +3198,11 @@ Stub_table<big_endian>::add_reloc_stub( Reloc_stub* stub, const Reloc_stub::Key& key) { - const Stub_template* stubtemplate = stub->stub_template(); - gold_assert(stubtemplate->type() == key.stub_type()); + const Stub_template* stub_template = stub->stub_template(); + gold_assert(stub_template->type() == key.stub_type()); this->reloc_stubs_[key] = stub; - if (this->addralign_ < stubtemplate->alignment()) - this->addralign_ = stubtemplate->alignment(); + if (this->addralign_ < stub_template->alignment()) + this->addralign_ = stub_template->alignment(); this->has_been_changed_ = true; } @@ -3211,14 +3211,14 @@ void Stub_table<big_endian>::relocate_stubs( const Relocate_info<32, big_endian>* relinfo, Target_arm<big_endian>* arm_target, - Output_section* out_section, + Output_section* output_section, unsigned char* view, - Arm_address addr, + Arm_address address, section_size_type view_size) { // If we are passed a view bigger than the stub table's. we need to // adjust the view. - gold_assert(addr == this->address() + gold_assert(address == this->address() && (view_size == static_cast<section_size_type>(this->data_size()))); @@ -3227,16 +3227,16 @@ Stub_table<big_endian>::relocate_stubs( ++p) { Reloc_stub* stub = p->second; - const Stub_template* stubtemplate = stub->stub_template(); - if (stubtemplate->reloc_count() != 0) + const Stub_template* stub_template = stub->stub_template(); + if (stub_template->reloc_count() != 0) { // Adjust view to cover the stub only. - section_size_type off = stub->offset(); - section_size_type stub_size = stubtemplate->size(); - gold_assert(off + stub_size <= view_size); + section_size_type offset = stub->offset(); + section_size_type stub_size = stub_template->size(); + gold_assert(offset + stub_size <= view_size); - arm_target->relocate_stub(stub, relinfo, out_section, - view + off, addr + off, + arm_target->relocate_stub(stub, relinfo, output_section, + view + offset, address + offset, stub_size); } } @@ -3255,13 +3255,13 @@ Stub_table<big_endian>::do_reset_address_and_file_offset() ++p) { Reloc_stub* stub = p->second; - const Stub_template* stubtemplate = stub->stub_template(); - uint64_t stub_addralign = stubtemplate->alignment(); + const Stub_template* stub_template = stub->stub_template(); + uint64_t stub_addralign = stub_template->alignment(); max_addralign = std::max(max_addralign, stub_addralign); off = align_address(off, stub_addralign); stub->set_offset(off); stub->reset_destination_address(); - off += stubtemplate->size(); + off += stub_template->size(); } this->addralign_ = max_addralign; @@ -3274,19 +3274,19 @@ template<bool big_endian> void Stub_table<big_endian>::do_write(Output_file* of) { - off_t off = this->offset(); + off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); for (typename Reloc_stub_map::const_iterator p = this->reloc_stubs_.begin(); p != this->reloc_stubs_.end(); ++p) { Reloc_stub* stub = p->second; - Arm_address addr = this->address() + stub->offset(); - gold_assert(addr - == align_address(addr, + Arm_address address = this->address() + stub->offset(); + gold_assert(address + == align_address(address, stub->stub_template()->alignment())); stub->write(oview + stub->offset(), stub->stub_template()->size(), big_endian); @@ -3302,21 +3302,21 @@ template<bool big_endian> void Arm_input_section<big_endian>::init() { - Relobj* rel_obj = this->relobj(); - unsigned int sec_shndx = this->shndx(); + Relobj* relobj = this->relobj(); + unsigned int shndx = this->shndx(); // Cache these to speed up size and alignment queries. It is too slow // to call section_addraglin and section_size every time. - this->original_addralign_ = rel_obj->section_addralign(sec_shndx); - this->original_size_ = rel_obj->section_size(sec_shndx); + this->original_addralign_ = relobj->section_addralign(shndx); + this->original_size_ = relobj->section_size(shndx); // We want to make this look like the original input section after // output sections are finalized. - Output_section* os = rel_obj->output_section(sec_shndx); - off_t off = rel_obj->output_section_offset(sec_shndx); - gold_assert(os != NULL && !rel_obj->is_output_section_offset_invalid(sec_shndx)); - this->set_address(os->address() + off); - this->set_file_offset(os->offset() + off); + Output_section* os = relobj->output_section(shndx); + off_t offset = relobj->output_section_offset(shndx); + gold_assert(os != NULL && !relobj->is_output_section_offset_invalid(shndx)); + this->set_address(os->address() + offset); + this->set_file_offset(os->offset() + offset); this->set_current_data_size(this->original_size_); this->finalize_data_size(); @@ -3346,15 +3346,15 @@ Arm_input_section<big_endian>::set_final_data_size() // If this owns a stub table, finalize its data size as well. if (this->is_stub_table_owner()) { - uint64_t addr = this->address(); + uint64_t address = this->address(); // The stub table comes after the original section contents. - addr += this->original_size_; - addr = align_address(addr, this->stub_table_->addralign()); - off_t off = this->offset() + (addr - this->address()); - this->stub_table_->set_address_and_file_offset(addr, off); - addr += this->stub_table_->data_size(); - gold_assert(addr == this->address() + this->current_data_size()); + address += this->original_size_; + address = align_address(address, this->stub_table_->addralign()); + off_t offset = this->offset() + (address - this->address()); + this->stub_table_->set_address_and_file_offset(address, offset); + address += this->stub_table_->data_size(); + gold_assert(address == this->address() + this->current_data_size()); } this->set_data_size(this->current_data_size()); @@ -3372,13 +3372,13 @@ Arm_input_section<big_endian>::do_reset_address_and_file_offset() // If this is a stub table owner, account for the stub table size. if (this->is_stub_table_owner()) { - Stub_table<big_endian>* stubtable = this->stub_table_; + Stub_table<big_endian>* stub_table = this->stub_table_; // Reset the stub table's address and file offset. The // current data size for child will be updated after that. stub_table_->reset_address_and_file_offset(); off = align_address(off, stub_table_->addralign()); - off += stubtable->current_data_size(); + off += stub_table->current_data_size(); } this->set_current_data_size(off); @@ -3420,10 +3420,10 @@ Arm_output_section<big_endian>::create_stub_group( } // Create a stub table. - Stub_table<big_endian>* stubtable = + Stub_table<big_endian>* stub_table = target->new_stub_table(arm_input_section); - arm_input_section->set_stub_table(stubtable); + arm_input_section->set_stub_table(stub_table); Input_section_list::const_iterator p = begin; Input_section_list::const_iterator prev_p; @@ -3437,7 +3437,7 @@ Arm_output_section<big_endian>::create_stub_group( // in their objects. Arm_relobj<big_endian>* arm_relobj = Arm_relobj<big_endian>::as_arm_relobj(p->relobj()); - arm_relobj->set_stub_table(p->shndx(), stubtable); + arm_relobj->set_stub_table(p->shndx(), stub_table); } prev_p = p++; } @@ -3489,7 +3489,7 @@ Arm_output_section<big_endian>::group_sections( section_size_type stub_table_end_offset = 0; Input_section_list::const_iterator group_begin = this->input_sections().end(); - Input_section_list::const_iterator stubtable = + Input_section_list::const_iterator stub_table = this->input_sections().end(); Input_section_list::const_iterator group_end = this->input_sections().end(); for (Input_section_list::const_iterator p = this->input_sections().begin(); @@ -3524,7 +3524,7 @@ Arm_output_section<big_endian>::group_sections( // stub_group_size bytes after the stub table can be // handled by it too. state = HAS_STUB_SECTION; - stubtable = group_end; + stub_table = group_end; stub_table_end_offset = group_end_offset; } } @@ -3536,7 +3536,7 @@ Arm_output_section<big_endian>::group_sections( if (section_end_offset - stub_table_end_offset >= group_size) { gold_assert(group_end != this->input_sections().end()); - this->create_stub_group(group_begin, group_end, stubtable, + this->create_stub_group(group_begin, group_end, stub_table, target, &new_relaxed_sections); state = NO_GROUP; } @@ -3573,7 +3573,7 @@ Arm_output_section<big_endian>::group_sections( this->create_stub_group(group_begin, group_end, (state == FINDING_STUB_SECTION ? group_end - : stubtable), + : stub_table), target, &new_relaxed_sections); } @@ -3587,9 +3587,9 @@ Arm_output_section<big_endian>::group_sections( Arm_relobj<big_endian>* arm_relobj = Arm_relobj<big_endian>::as_arm_relobj( new_relaxed_sections[i]->relobj()); - unsigned int sec_shndx = new_relaxed_sections[i]->shndx(); + unsigned int shndx = new_relaxed_sections[i]->shndx(); // Tell Arm_relobj that this input section is converted. - arm_relobj->convert_input_section_to_relaxed_section(sec_shndx); + arm_relobj->convert_input_section_to_relaxed_section(shndx); } } @@ -3602,14 +3602,14 @@ void Arm_relobj<big_endian>::scan_sections_for_stubs( Target_arm<big_endian>* arm_target, const Symbol_table* symtab, - const Layout* alayout) + const Layout* layout) { - unsigned int sec_shnum = this->shnum(); - const unsigned int shdrsize = elfcpp::Elf_sizes<32>::shdr_size; + unsigned int shnum = this->shnum(); + const unsigned int shdr_size = elfcpp::Elf_sizes<32>::shdr_size; // Read the section headers. const unsigned char* pshdrs = this->get_view(this->elf_file()->shoff(), - sec_shnum * shdrsize, + shnum * shdr_size, true, true); // To speed up processing, we set up hash tables for fast lookup of @@ -3620,11 +3620,11 @@ Arm_relobj<big_endian>::scan_sections_for_stubs( Relocate_info<32, big_endian> relinfo; relinfo.symtab = symtab; - relinfo.layout = alayout; + relinfo.layout = layout; relinfo.object = this; - const unsigned char* p = pshdrs + shdrsize; - for (unsigned int i = 1; i < sec_shnum; ++i, p += shdrsize) + const unsigned char* p = pshdrs + shdr_size; + for (unsigned int i = 1; i < shnum; ++i, p += shdr_size) { typename elfcpp::Shdr<32, big_endian> shdr(p); @@ -3738,15 +3738,15 @@ Arm_relobj<big_endian>::do_count_local_symbols( this->local_symbol_is_thumb_function_.swap(empty_vector); // Read the symbol table section header. - const unsigned int sym_tab_shndx = this->symtab_shndx(); + const unsigned int symtab_shndx = this->symtab_shndx(); elfcpp::Shdr<32, big_endian> - symtabshdr(this, this->elf_file()->section_header(sym_tab_shndx)); + symtabshdr(this, this->elf_file()->section_header(symtab_shndx)); gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); // Read the local symbols. - const int symsize =elfcpp::Elf_sizes<32>::sym_size; + const int sym_size =elfcpp::Elf_sizes<32>::sym_size; gold_assert(loccount == symtabshdr.get_sh_info()); - off_t locsize = loccount * symsize; + off_t locsize = loccount * sym_size; const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), locsize, true, true); @@ -3754,10 +3754,10 @@ Arm_relobj<big_endian>::do_count_local_symbols( // to THUMB functions. // Skip the first dummy symbol. - psyms += symsize; + psyms += sym_size; typename Sized_relobj<32, big_endian>::Local_values* plocal_values = this->local_values(); - for (unsigned int i = 1; i < loccount; ++i, psyms += symsize) + for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) { elfcpp::Sym<32, big_endian> sym(psyms); elfcpp::STT st_type = sym.get_st_type(); @@ -3781,12 +3781,12 @@ template<bool big_endian> void Arm_relobj<big_endian>::do_relocate_sections( const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, const unsigned char* pshdrs, typename Sized_relobj<32, big_endian>::Views* pviews) { // Call parent to relocate sections. - Sized_relobj<32, big_endian>::do_relocate_sections(symtab, alayout, pshdrs, + Sized_relobj<32, big_endian>::do_relocate_sections(symtab, layout, pshdrs, pviews); // We do not generate stubs if doing a relocatable link. @@ -3794,17 +3794,17 @@ Arm_relobj<big_endian>::do_relocate_sections( return; // Relocate stub tables. - unsigned int sec_shnum = this->shnum(); + unsigned int shnum = this->shnum(); Target_arm<big_endian>* arm_target = Target_arm<big_endian>::default_target(); Relocate_info<32, big_endian> relinfo; relinfo.symtab = symtab; - relinfo.layout = alayout; + relinfo.layout = layout; relinfo.object = this; - for (unsigned int i = 1; i < sec_shnum; ++i) + for (unsigned int i = 1; i < shnum; ++i) { Arm_input_section<big_endian>* arm_input_section = arm_target->find_arm_input_section(this, i); @@ -3827,18 +3827,18 @@ Arm_relobj<big_endian>::do_relocate_sections( // We are passed the output section view. Adjust it to cover the // stub table only. - Stub_table<big_endian>* stubtable = arm_input_section->stub_table(); - gold_assert((stubtable->address() >= (*pviews)[i].address) - && ((stubtable->address() + stubtable->data_size()) + Stub_table<big_endian>* stub_table = arm_input_section->stub_table(); + gold_assert((stub_table->address() >= (*pviews)[i].address) + && ((stub_table->address() + stub_table->data_size()) <= (*pviews)[i].address + (*pviews)[i].view_size)); - off_t off = stubtable->address() - (*pviews)[i].address; - unsigned char* pview = (*pviews)[i].view + off; - Arm_address address = stubtable->address(); - section_size_type view_size = stubtable->data_size(); + off_t offset = stub_table->address() - (*pviews)[i].address; + unsigned char* view = (*pviews)[i].view + offset; + Arm_address address = stub_table->address(); + section_size_type view_size = stub_table->data_size(); - stubtable->relocate_stubs(&relinfo, arm_target, os, pview, address, - view_size); + stub_table->relocate_stubs(&relinfo, arm_target, os, view, address, + view_size); } } @@ -4043,13 +4043,13 @@ class Output_data_plt_arm : public Output_section_data // section just for PLT entries. template<bool big_endian> -Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* alayout, +Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* layout, Output_data_space* got_plt) : Output_section_data(4), got_plt_(got_plt), count_(0) { this->rel_ = new Reloc_section(false); - alayout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, - elfcpp::SHF_ALLOC, this->rel_, true); + layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL, + elfcpp::SHF_ALLOC, this->rel_, true); } template<bool big_endian> @@ -4125,10 +4125,10 @@ template<bool big_endian> void Output_data_plt_arm<big_endian>::do_write(Output_file* of) { - const off_t off = this->offset(); + const off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); const off_t got_file_offset = this->got_plt_->offset(); const section_size_type got_size = @@ -4170,15 +4170,15 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) got_offset += 4) { // Set and adjust the PLT entry itself. - int32_t offst = ((got_address + got_offset) - - (plt_address + plt_offset + 8)); + int32_t offset = ((got_address + got_offset) + - (plt_address + plt_offset + 8)); - gold_assert(offst >= 0 && offst < 0x0fffffff); - uint32_t plt_insn0 = plt_entry[0] | ((offst >> 20) & 0xff); + gold_assert(offset >= 0 && offset < 0x0fffffff); + uint32_t plt_insn0 = plt_entry[0] | ((offset >> 20) & 0xff); elfcpp::Swap<32, big_endian>::writeval(pov, plt_insn0); - uint32_t plt_insn1 = plt_entry[1] | ((offst >> 12) & 0xff); + uint32_t plt_insn1 = plt_entry[1] | ((offset >> 12) & 0xff); elfcpp::Swap<32, big_endian>::writeval(pov + 4, plt_insn1); - uint32_t plt_insn2 = plt_entry[2] | (offst & 0xfff); + uint32_t plt_insn2 = plt_entry[2] | (offset & 0xfff); elfcpp::Swap<32, big_endian>::writeval(pov + 8, plt_insn2); // Set the entry in the GOT. @@ -4188,7 +4188,7 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); of->write_output_view(got_file_offset, got_size, got_view); } @@ -4196,7 +4196,7 @@ Output_data_plt_arm<big_endian>::do_write(Output_file* of) template<bool big_endian> void -Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* alayout, +Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* layout, Symbol* gsym) { if (gsym->has_plt_offset()) @@ -4205,13 +4205,13 @@ Target_arm<big_endian>::make_plt_entry(Symbol_table* symtab, Layout* alayout, if (this->plt_ == NULL) { // Create the GOT sections first. - this->got_section(symtab, alayout); + this->got_section(symtab, layout); - this->plt_ = new Output_data_plt_arm<big_endian>(alayout, this->got_plt_); - alayout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, - (elfcpp::SHF_ALLOC - | elfcpp::SHF_EXECINSTR), - this->plt_, false); + this->plt_ = new Output_data_plt_arm<big_endian>(layout, this->got_plt_); + layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS, + (elfcpp::SHF_ALLOC + | elfcpp::SHF_EXECINSTR), + this->plt_, false); } this->plt_->add_entry(gsym); } @@ -4281,7 +4281,7 @@ Target_arm<big_endian>::Scan::check_non_pic(Relobj* object, template<bool big_endian> inline void Target_arm<big_endian>::Scan::local(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Target_arm* target, Sized_relobj<32, big_endian>* object, unsigned int data_shndx, @@ -4306,7 +4306,7 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab, // relocate it easily. if (parameters->options().output_is_position_independent()) { - Reloc_section* rel_dyn = target->rel_dyn_section(alayout); + Reloc_section* rel_dyn = target->rel_dyn_section(layout); unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); // If we are to add more other reloc types than R_ARM_ABS32, // we need to add check_non_pic(object, r_type) here. @@ -4339,7 +4339,7 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab, case elfcpp::R_ARM_GOTOFF32: // We need a GOT section: - target->got_section(symtab, alayout); + target->got_section(symtab, layout); break; case elfcpp::R_ARM_BASE_PREL: @@ -4351,7 +4351,7 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab, { // The symbol requires a GOT entry. Output_data_got<32, big_endian>* got = - target->got_section(symtab, alayout); + target->got_section(symtab, layout); unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); if (got->add_local(object, r_sym, GOT_TYPE_STANDARD)) { @@ -4359,11 +4359,11 @@ Target_arm<big_endian>::Scan::local(Symbol_table* symtab, // dynamic RELATIVE relocation for this symbol's GOT entry. if (parameters->options().output_is_position_independent()) { - Reloc_section* rel_dyn = target->rel_dyn_section(alayout); - unsigned int rsym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); + Reloc_section* rel_dyn = target->rel_dyn_section(layout); + unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); rel_dyn->add_local_relative( - object, rsym, elfcpp::R_ARM_RELATIVE, got, - object->local_got_offset(rsym, GOT_TYPE_STANDARD)); + object, r_sym, elfcpp::R_ARM_RELATIVE, got, + object->local_got_offset(r_sym, GOT_TYPE_STANDARD)); } } } @@ -4408,7 +4408,7 @@ Target_arm<big_endian>::Scan::unsupported_reloc_global( template<bool big_endian> inline void Target_arm<big_endian>::Scan::global(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Target_arm* target, Sized_relobj<32, big_endian>* object, unsigned int data_shndx, @@ -4431,14 +4431,14 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, { if (target->may_need_copy_reloc(gsym)) { - target->copy_reloc(symtab, alayout, object, + target->copy_reloc(symtab, layout, object, data_shndx, output_section, gsym, reloc); } else if (gsym->can_use_relative_reloc(false)) { // If we are to add more other reloc types than R_ARM_ABS32, // we need to add check_non_pic(object, r_type) here. - Reloc_section* rel_dyn = target->rel_dyn_section(alayout); + Reloc_section* rel_dyn = target->rel_dyn_section(layout); rel_dyn->add_global_relative(gsym, elfcpp::R_ARM_RELATIVE, output_section, object, data_shndx, reloc.get_r_offset()); @@ -4447,7 +4447,7 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, { // If we are to add more other reloc types than R_ARM_ABS32, // we need to add check_non_pic(object, r_type) here. - Reloc_section* rel_dyn = target->rel_dyn_section(alayout); + Reloc_section* rel_dyn = target->rel_dyn_section(layout); rel_dyn->add_global(gsym, r_type, output_section, object, data_shndx, reloc.get_r_offset()); } @@ -4491,13 +4491,13 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, { if (target->may_need_copy_reloc(gsym)) { - target->copy_reloc(symtab, alayout, object, + target->copy_reloc(symtab, layout, object, data_shndx, output_section, gsym, reloc); } else { check_non_pic(object, r_type); - Reloc_section* rel_dyn = target->rel_dyn_section(alayout); + Reloc_section* rel_dyn = target->rel_dyn_section(layout); rel_dyn->add_global(gsym, r_type, output_section, object, data_shndx, reloc.get_r_offset()); } @@ -4511,7 +4511,7 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, case elfcpp::R_ARM_THM_CALL: if (Target_arm<big_endian>::Scan::symbol_needs_plt_entry(gsym)) - target->make_plt_entry(symtab, alayout, gsym); + target->make_plt_entry(symtab, layout, gsym); else { // Check to see if this is a function that would need a PLT @@ -4540,12 +4540,12 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, && !gsym->is_from_dynobj() && !gsym->is_preemptible()) break; - target->make_plt_entry(symtab, alayout, gsym); + target->make_plt_entry(symtab, layout, gsym); break; case elfcpp::R_ARM_GOTOFF32: // We need a GOT section. - target->got_section(symtab, alayout); + target->got_section(symtab, layout); break; case elfcpp::R_ARM_BASE_PREL: @@ -4557,14 +4557,14 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, { // The symbol requires a GOT entry. Output_data_got<32, big_endian>* got = - target->got_section(symtab, alayout); + target->got_section(symtab, layout); if (gsym->final_value_is_known()) got->add_global(gsym, GOT_TYPE_STANDARD); else { // If this symbol is not fully resolved, we need to add a // GOT entry with a dynamic relocation. - Reloc_section* rel_dyn = target->rel_dyn_section(alayout); + Reloc_section* rel_dyn = target->rel_dyn_section(layout); if (gsym->is_from_dynobj() || gsym->is_undefined() || gsym->is_preemptible()) @@ -4605,7 +4605,7 @@ Target_arm<big_endian>::Scan::global(Symbol_table* symtab, template<bool big_endian> void Target_arm<big_endian>::gc_process_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Sized_relobj<32, big_endian>* object, unsigned int data_shndx, unsigned int, @@ -4617,11 +4617,11 @@ Target_arm<big_endian>::gc_process_relocs(Symbol_table* symtab, const unsigned char* plocal_symbols) { typedef Target_arm<big_endian> Arm; - typedef typename Target_arm<big_endian>::Scan scan; + typedef typename Target_arm<big_endian>::Scan Scan; - gold::gc_process_relocs<32, big_endian, Arm, elfcpp::SHT_REL, scan>( + gold::gc_process_relocs<32, big_endian, Arm, elfcpp::SHT_REL, Scan>( symtab, - alayout, + layout, this, object, data_shndx, @@ -4638,7 +4638,7 @@ Target_arm<big_endian>::gc_process_relocs(Symbol_table* symtab, template<bool big_endian> void Target_arm<big_endian>::scan_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Sized_relobj<32, big_endian>* object, unsigned int data_shndx, unsigned int sh_type, @@ -4649,7 +4649,7 @@ Target_arm<big_endian>::scan_relocs(Symbol_table* symtab, size_t local_symbol_count, const unsigned char* plocal_symbols) { - typedef typename Target_arm<big_endian>::Scan scan; + typedef typename Target_arm<big_endian>::Scan Scan; if (sh_type == elfcpp::SHT_RELA) { gold_error(_("%s: unsupported RELA reloc section"), @@ -4657,9 +4657,9 @@ Target_arm<big_endian>::scan_relocs(Symbol_table* symtab, return; } - gold::scan_relocs<32, big_endian, Target_arm, elfcpp::SHT_REL, scan>( + gold::scan_relocs<32, big_endian, Target_arm, elfcpp::SHT_REL, Scan>( symtab, - alayout, + layout, this, object, data_shndx, @@ -4676,7 +4676,7 @@ Target_arm<big_endian>::scan_relocs(Symbol_table* symtab, template<bool big_endian> void Target_arm<big_endian>::do_finalize_sections( - Layout* alayout, + Layout* layout, const Input_objects* input_objects, Symbol_table* symtab) { @@ -4715,7 +4715,7 @@ Target_arm<big_endian>::do_finalize_sections( this->set_may_use_blx(true); // Fill in some more dynamic tags. - Output_data_dynamic* const odyn = alayout->dynamic_data(); + Output_data_dynamic* const odyn = layout->dynamic_data(); if (odyn != NULL) { if (this->got_plt_ != NULL @@ -4752,10 +4752,10 @@ Target_arm<big_endian>::do_finalize_sections( // Emit any relocs we saved in an attempt to avoid generating COPY // relocs. if (this->copy_relocs_.any_saved_relocs()) - this->copy_relocs_.emit(this->rel_dyn_section(alayout)); + this->copy_relocs_.emit(this->rel_dyn_section(layout)); // Handle the .ARM.exidx section. - Output_section* exidx_section = alayout->find_output_section(".ARM.exidx"); + Output_section* exidx_section = layout->find_output_section(".ARM.exidx"); if (exidx_section != NULL && exidx_section->type() == elfcpp::SHT_ARM_EXIDX && !parameters->options().relocatable()) @@ -4772,22 +4772,23 @@ Target_arm<big_endian>::do_finalize_sections( // For the ARM target, we need to add a PT_ARM_EXIDX segment for // the .ARM.exidx section. - if (!alayout->script_options()->saw_phdrs_clause()) + if (!layout->script_options()->saw_phdrs_clause()) { - gold_assert(alayout->find_output_segment(elfcpp::PT_ARM_EXIDX, 0, 0) + gold_assert(layout->find_output_segment(elfcpp::PT_ARM_EXIDX, 0, 0) == NULL); Output_segment* exidx_segment = - alayout->make_output_segment(elfcpp::PT_ARM_EXIDX, elfcpp::PF_R); + layout->make_output_segment(elfcpp::PT_ARM_EXIDX, elfcpp::PF_R); exidx_segment->add_output_section(exidx_section, elfcpp::PF_R, false); } } // Create an .ARM.attributes section if there is not one already. - Output_attributes_section_data* as = + Output_attributes_section_data* attributes_section = new Output_attributes_section_data(*this->attributes_section_data_); - alayout->add_output_section_data(".ARM.attributes", - elfcpp::SHT_ARM_ATTRIBUTES, 0, as, false); + layout->add_output_section_data(".ARM.attributes", + elfcpp::SHT_ARM_ATTRIBUTES, 0, + attributes_section, false); } // Return whether a direct absolute static relocation needs to be applied. @@ -5285,9 +5286,9 @@ Target_arm<big_endian>::relocate_section( + arm_input_section->data_size()) <= (address + view_size))); - off_t off = section_address - address; - view += off; - address += off; + off_t offset = section_address - address; + view += offset; + address += offset; view_size = section_size; } @@ -5376,7 +5377,7 @@ template<bool big_endian> void Target_arm<big_endian>::scan_relocatable_relocs( Symbol_table* symtab, - Layout* alayout, + Layout* layout, Sized_relobj<32, big_endian>* object, unsigned int data_shndx, unsigned int sh_type, @@ -5396,7 +5397,7 @@ Target_arm<big_endian>::scan_relocatable_relocs( gold::scan_relocatable_relocs<32, big_endian, elfcpp::SHT_REL, Scan_relocatable_relocs>( symtab, - alayout, + layout, object, data_shndx, prelocs, @@ -5575,20 +5576,20 @@ Object* Target_arm<big_endian>::do_make_elf_object( const std::string& name, Input_file* input_file, - off_t off, const elfcpp::Ehdr<32, big_endian>& ehdr) + off_t offset, const elfcpp::Ehdr<32, big_endian>& ehdr) { int et = ehdr.get_e_type(); if (et == elfcpp::ET_REL) { Arm_relobj<big_endian>* obj = - new Arm_relobj<big_endian>(name, input_file, off, ehdr); + new Arm_relobj<big_endian>(name, input_file, offset, ehdr); obj->setup(); return obj; } else if (et == elfcpp::ET_DYN) { Sized_dynobj<32, big_endian>* obj = - new Arm_dynobj<big_endian>(name, input_file, off, ehdr); + new Arm_dynobj<big_endian>(name, input_file, offset, ehdr); obj->setup(); return obj; } @@ -6423,13 +6424,13 @@ Target_arm<big_endian>::reloc_uses_thumb_bit(unsigned int r_type) template<bool big_endian> Arm_input_section<big_endian>* Target_arm<big_endian>::new_arm_input_section( - Relobj* rel_obj, - unsigned int sec_shndx) + Relobj* relobj, + unsigned int shndx) { - Input_section_specifier iss(rel_obj, sec_shndx); + Input_section_specifier iss(relobj, shndx); Arm_input_section<big_endian>* arm_input_section = - new Arm_input_section<big_endian>(rel_obj, sec_shndx); + new Arm_input_section<big_endian>(relobj, shndx); arm_input_section->init(); // Register new Arm_input_section in map for look-up. @@ -6449,10 +6450,10 @@ Target_arm<big_endian>::new_arm_input_section( template<bool big_endian> Arm_input_section<big_endian>* Target_arm<big_endian>::find_arm_input_section( - Relobj* rel_obj, - unsigned int sec_shndx) const + Relobj* relobj, + unsigned int shndx) const { - Input_section_specifier iss(rel_obj, sec_shndx); + Input_section_specifier iss(relobj, shndx); typename Arm_input_section_map::const_iterator p = this->arm_input_section_map_.find(iss); return (p != this->arm_input_section_map_.end()) ? p->second : NULL; @@ -6464,15 +6465,15 @@ template<bool big_endian> Stub_table<big_endian>* Target_arm<big_endian>::new_stub_table(Arm_input_section<big_endian>* owner) { - Stub_table<big_endian>* stubtable = + Stub_table<big_endian>* stub_table = new Stub_table<big_endian>(owner); - this->stub_tables_.push_back(stubtable); + this->stub_tables_.push_back(stub_table); - stubtable->set_address(owner->address() + owner->data_size()); - stubtable->set_file_offset(owner->offset() + owner->data_size()); - stubtable->finalize_data_size(); + stub_table->set_address(owner->address() + owner->data_size()); + stub_table->set_file_offset(owner->offset() + owner->data_size()); + stub_table->finalize_data_size(); - return stubtable; + return stub_table; } // Scan a relocation for stub generation. @@ -6488,7 +6489,7 @@ Target_arm<big_endian>::scan_reloc_for_stub( elfcpp::Elf_types<32>::Elf_Swxword addend, Arm_address address) { - typedef typename Target_arm<big_endian>::Relocate relocate; + typedef typename Target_arm<big_endian>::Relocate Relocate; const Arm_relobj<big_endian>* arm_relobj = Arm_relobj<big_endian>::as_arm_relobj(relinfo->object); @@ -6499,7 +6500,7 @@ Target_arm<big_endian>::scan_reloc_for_stub( { // This is a global symbol. Determine if we use PLT and if the // final target is THUMB. - if (gsym->use_plt_offset(relocate::reloc_is_non_pic(r_type))) + if (gsym->use_plt_offset(Relocate::reloc_is_non_pic(r_type))) { // This uses a PLT, change the symbol value. symval.set_output_value(this->plt_section()->address() @@ -6570,20 +6571,20 @@ Target_arm<big_endian>::scan_reloc_for_stub( return; // Try looking up an existing stub from a stub table. - Stub_table<big_endian>* stubtable = + Stub_table<big_endian>* stub_table = arm_relobj->stub_table(relinfo->data_shndx); - gold_assert(stubtable != NULL); + gold_assert(stub_table != NULL); // Locate stub by destination. Reloc_stub::Key stub_key(stub_type, gsym, arm_relobj, r_sym, addend); // Create a stub if there is not one already - Reloc_stub* stub = stubtable->find_reloc_stub(stub_key); + Reloc_stub* stub = stub_table->find_reloc_stub(stub_key); if (stub == NULL) { // create a new stub and add it to stub table. stub = this->stub_factory().make_reloc_stub(stub_type); - stubtable->add_reloc_stub(stub, stub_key); + stub_table->add_reloc_stub(stub, stub_key); } // Record the destination address. @@ -6652,22 +6653,22 @@ Target_arm<big_endian>::scan_reloc_section_for_stubs( && (r_type != elfcpp::R_ARM_THM_JUMP19)) continue; - section_offset_type off = + section_offset_type offset = convert_to_section_size_type(reloc.get_r_offset()); if (needs_special_offset_handling) { - off = output_section->output_offset(relinfo->object, - relinfo->data_shndx, - off); - if (off == -1) + offset = output_section->output_offset(relinfo->object, + relinfo->data_shndx, + offset); + if (offset == -1) continue; } // Get the addend. Stub_addend_reader<sh_type, big_endian> stub_addend_reader; elfcpp::Elf_types<32>::Elf_Swxword addend = - stub_addend_reader(r_type, view + off, reloc); + stub_addend_reader(r_type, view + offset, reloc); const Sized_symbol<32>* sym; @@ -6684,11 +6685,11 @@ Target_arm<big_endian>::scan_reloc_section_for_stubs( // counterpart in the kept section. The symbol must not // correspond to a section we are folding. bool is_ordinary; - unsigned int sec_shndx = psymval->input_shndx(&is_ordinary); + unsigned int shndx = psymval->input_shndx(&is_ordinary); if (is_ordinary - && sec_shndx != elfcpp::SHN_UNDEF - && !arm_object->is_section_included(sec_shndx) - && !(relinfo->symtab->is_section_folded(arm_object, sec_shndx))) + && shndx != elfcpp::SHN_UNDEF + && !arm_object->is_section_included(shndx) + && !(relinfo->symtab->is_section_folded(arm_object, shndx))) { if (comdat_behavior == CB_UNDETERMINED) { @@ -6700,7 +6701,7 @@ Target_arm<big_endian>::scan_reloc_section_for_stubs( { bool found; typename elfcpp::Elf_types<32>::Elf_Addr value = - arm_object->map_to_kept_section(sec_shndx, &found); + arm_object->map_to_kept_section(shndx, &found); if (found) symval.set_output_value(value + psymval->input_value()); else @@ -6750,7 +6751,7 @@ Target_arm<big_endian>::scan_reloc_section_for_stubs( continue; this->scan_reloc_for_stub(relinfo, r_type, sym, r_sym, psymval, - addend, view_address + off); + addend, view_address + offset); } } @@ -6808,13 +6809,13 @@ Target_arm<big_endian>::scan_section_for_stubs( template<bool big_endian> void Target_arm<big_endian>::group_sections( - Layout* alayout, + Layout* layout, section_size_type group_size, bool stubs_always_after_branch) { // Group input sections and insert stub table Layout::Section_list section_list; - alayout->get_allocated_sections(§ion_list); + layout->get_allocated_sections(§ion_list); for (Layout::Section_list::const_iterator p = section_list.begin(); p != section_list.end(); ++p) @@ -6834,7 +6835,7 @@ Target_arm<big_endian>::do_relax( int pass, const Input_objects* input_objects, Symbol_table* symtab, - Layout* alayout) + Layout* layout) { // No need to generate stubs if this is a relocatable link. gold_assert(!parameters->options().relocatable()); @@ -6866,7 +6867,7 @@ Target_arm<big_endian>::do_relax( stub_group_size = 4170000; } - group_sections(alayout, stub_group_size, stubs_always_after_branch); + group_sections(layout, stub_group_size, stubs_always_after_branch); } // clear changed flags for all stub_tables @@ -6883,7 +6884,7 @@ Target_arm<big_endian>::do_relax( { Arm_relobj<big_endian>* arm_relobj = Arm_relobj<big_endian>::as_arm_relobj(*op); - arm_relobj->scan_sections_for_stubs(this, symtab, alayout); + arm_relobj->scan_sections_for_stubs(this, symtab, layout); } bool any_stub_table_changed = false; @@ -6911,14 +6912,14 @@ Target_arm<big_endian>::relocate_stub( section_size_type view_size) { Relocate relocate; - const Stub_template* stubtemplate = stub->stub_template(); - for (size_t i = 0; i < stubtemplate->reloc_count(); i++) + const Stub_template* stub_template = stub->stub_template(); + for (size_t i = 0; i < stub_template->reloc_count(); i++) { - size_t reloc_insn_index = stubtemplate->reloc_insn_index(i); - const Insn_template* insn = &stubtemplate->insns()[reloc_insn_index]; + size_t reloc_insn_index = stub_template->reloc_insn_index(i); + const Insn_template* insn = &stub_template->insns()[reloc_insn_index]; unsigned int r_type = insn->r_type(); - section_size_type reloc_offset = stubtemplate->reloc_offset(i); + section_size_type reloc_offset = stub_template->reloc_offset(i); section_size_type reloc_size = insn->size(); gold_assert(reloc_offset + reloc_size <= view_size); diff --git a/gold/attributes.cc b/gold/attributes.cc index 7d82979..6b2260d 100644 --- a/gold/attributes.cc +++ b/gold/attributes.cc @@ -45,12 +45,12 @@ Object_attribute::size(int tag) const if (this->is_default_attribute()) return 0; - size_t uleb128_size = get_length_as_unsigned_LEB_128(tag); + size_t size = get_length_as_unsigned_LEB_128(tag); if (Object_attribute::attribute_type_has_int_value(this->type_)) - uleb128_size += get_length_as_unsigned_LEB_128(this->int_value_); + size += get_length_as_unsigned_LEB_128(this->int_value_); if (Object_attribute::attribute_type_has_string_value(this->type_)) - uleb128_size += this->string_value_.size() + 1; - return uleb128_size; + size += this->string_value_.size() + 1; + return size; } // Whether this has the default value (0/""). @@ -266,11 +266,11 @@ Attributes_section_data::size() const } // Construct an Attributes_section_data object by parsing section contents -// specified by VIEW and VIEW_SIZE. +// specified by VIEW and SIZE. Attributes_section_data::Attributes_section_data( const unsigned char* view, - section_size_type view_size) + section_size_type size) { for (int vendor = OBJ_ATTR_FIRST; vendor <= OBJ_ATTR_LAST; ++vendor) this->vendor_object_attributes_[vendor] = @@ -280,16 +280,16 @@ Attributes_section_data::Attributes_section_data( p = view; if (*(p++) == 'A') { - view_size--; - while (view_size > 0) + size--; + while (size > 0) { // Size of vendor attributes section. section_size_type section_size = convert_to_section_size_type(read_from_pointer<32>(&p)); - if (section_size > view_size) - section_size = view_size; - view_size -= section_size; + if (section_size > size) + section_size = size; + size -= section_size; const char* section_name = reinterpret_cast<const char*>(p); section_size_type section_name_size = strlen(section_name) + 1; @@ -443,9 +443,10 @@ Attributes_section_data::write(std::vector<unsigned char>* buffer) const void Output_attributes_section_data::do_write(Output_file* of) { + off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(this->offset(), oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); std::vector<unsigned char> buffer; this->attributes_section_data_.write(&buffer); diff --git a/gold/attributes.h b/gold/attributes.h index dbfba84..7c4baf4 100644 --- a/gold/attributes.h +++ b/gold/attributes.h @@ -103,8 +103,8 @@ class Object_attribute // Set attribute type. void - set_type(int at) - { this->type_ = at; } + set_type(int type) + { this->type_ = type; } // Return integer value. unsigned int diff --git a/gold/compressed_output.cc b/gold/compressed_output.cc index 814bd25..a0f8ed1 100644 --- a/gold/compressed_output.cc +++ b/gold/compressed_output.cc @@ -1,6 +1,6 @@ // compressed_output.cc -- manage compressed output sections for gold -// Copyright 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -137,14 +137,14 @@ Output_compressed_section::set_final_data_size() void Output_compressed_section::do_write(Output_file* of) { - off_t off = this->offset(); - off_t datasize = this->data_size(); - unsigned char* view = of->get_output_view(off, datasize); + off_t offset = this->offset(); + off_t data_size = this->data_size(); + unsigned char* view = of->get_output_view(offset, data_size); if (this->data_ == NULL) - memcpy(view, this->postprocessing_buffer(), datasize); + memcpy(view, this->postprocessing_buffer(), data_size); else - memcpy(view, this->data_, datasize); - of->write_output_view(off, datasize, view); + memcpy(view, this->data_, data_size); + of->write_output_view(offset, data_size, view); } } // End namespace gold. diff --git a/gold/compressed_output.h b/gold/compressed_output.h index 86e3c01..11b2762 100644 --- a/gold/compressed_output.h +++ b/gold/compressed_output.h @@ -1,6 +1,6 @@ // compressed_output.h -- compressed output sections for gold -*- C++ -*- -// Copyright 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -45,9 +45,9 @@ class Output_compressed_section : public Output_section { public: Output_compressed_section(const General_options* options, - const char* cname, elfcpp::Elf_Word cflags, - elfcpp::Elf_Xword ctype) - : Output_section(cname, cflags, ctype), + const char* name, elfcpp::Elf_Word flags, + elfcpp::Elf_Xword type) + : Output_section(name, flags, type), options_(options) { this->set_requires_postprocessing(); } diff --git a/gold/configure b/gold/configure index 3f67d29..30bd132 100755 --- a/gold/configure +++ b/gold/configure @@ -6331,7 +6331,7 @@ fi -WARN_CXXFLAGS=`echo ${WARN_CFLAGS} | sed -e 's/-Wstrict-prototypes//' -e 's/-Wmissing-prototypes//'` +WARN_CXXFLAGS=`echo ${WARN_CFLAGS} | sed -e 's/-Wstrict-prototypes//' -e 's/-Wmissing-prototypes//' -e 's/-Wshadow//'` LFS_CFLAGS="-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64" diff --git a/gold/configure.ac b/gold/configure.ac index 4307732..2f9cc43 100644 --- a/gold/configure.ac +++ b/gold/configure.ac @@ -312,7 +312,7 @@ AC_SUBST(RANDOM_SEED_CFLAGS) AM_BINUTILS_WARNINGS -WARN_CXXFLAGS=`echo ${WARN_CFLAGS} | sed -e 's/-Wstrict-prototypes//' -e 's/-Wmissing-prototypes//'` +WARN_CXXFLAGS=`echo ${WARN_CFLAGS} | sed -e 's/-Wstrict-prototypes//' -e 's/-Wmissing-prototypes//' -e 's/-Wshadow//'` AC_SUBST(WARN_CXXFLAGS) dnl Force support for large files by default. This may need to be diff --git a/gold/dwarf_reader.cc b/gold/dwarf_reader.cc index c8d29cd..4062fe6 100644 --- a/gold/dwarf_reader.cc +++ b/gold/dwarf_reader.cc @@ -294,7 +294,7 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode( case elfcpp::DW_LNS_advance_pc: { const uint64_t advance_address - = read_unsigned_LEB_128(start, &templen); + = read_unsigned_LEB_128(start, &templen); oplen += templen; lsm->address += header_.min_insn_length * advance_address; } @@ -353,7 +353,7 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode( case elfcpp::DW_LNS_extended_op: { const uint64_t extended_op_len - = read_unsigned_LEB_128(start, &templen); + = read_unsigned_LEB_128(start, &templen); start += templen; oplen += templen + extended_op_len; @@ -375,7 +375,7 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode( { lsm->address = elfcpp::Swap_unaligned<size, big_endian>::readval(start); typename Reloc_map::const_iterator it - = reloc_map_.find(start - this->buffer_); + = reloc_map_.find(start - this->buffer_); if (it != reloc_map_.end()) { // value + addend. @@ -420,16 +420,17 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode( default: { - // Ignore unknown opcode silently. + // Ignore unknown opcode silently for (int i = 0; i < header_.std_opcode_lengths[opcode]; i++) { + size_t templen; read_unsigned_LEB_128(start, &templen); start += templen; oplen += templen; } } break; - } + } *len = oplen; return false; } diff --git a/gold/dynobj.cc b/gold/dynobj.cc index 80d4a43..1b0dad9 100644 --- a/gold/dynobj.cc +++ b/gold/dynobj.cc @@ -39,8 +39,8 @@ namespace gold // Sets up the default soname_ to use, in the (rare) cases we never // see a DT_SONAME entry. -Dynobj::Dynobj(const std::string& aname, Input_file* ainput_file, off_t aoffset) - : Object(aname, ainput_file, true, aoffset), +Dynobj::Dynobj(const std::string& name, Input_file* input_file, off_t offset) + : Object(name, input_file, true, offset), needed_(), unknown_needed_(UNKNOWN_NEEDED_UNSET) { @@ -67,11 +67,11 @@ Dynobj::Dynobj(const std::string& aname, Input_file* ainput_file, off_t aoffset) template<int size, bool big_endian> Sized_dynobj<size, big_endian>::Sized_dynobj( - const std::string& aname, - Input_file* ainput_file, - off_t aoffset, + const std::string& name, + Input_file* input_file, + off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr) - : Dynobj(aname, ainput_file, aoffset), + : Dynobj(name, input_file, offset), elf_file_(this, ehdr), dynsym_shndx_(-1U), symbols_(NULL), @@ -85,8 +85,8 @@ template<int size, bool big_endian> void Sized_dynobj<size, big_endian>::setup() { - const unsigned int sec_shnum = this->elf_file_.shnum(); - this->set_shnum(sec_shnum); + const unsigned int shnum = this->elf_file_.shnum(); + this->set_shnum(shnum); } // Find the SHT_DYNSYM section and the various version sections, and @@ -108,9 +108,9 @@ Sized_dynobj<size, big_endian>::find_dynsym_sections( unsigned int xindex_shndx = 0; unsigned int xindex_link = 0; - const unsigned int sec_shnum = this->shnum(); + const unsigned int shnum = this->shnum(); const unsigned char* p = pshdrs; - for (unsigned int i = 0; i < sec_shnum; ++i, p += This::shdr_size) + for (unsigned int i = 0; i < shnum; ++i, p += This::shdr_size) { typename This::Shdr shdr(p); @@ -180,13 +180,13 @@ Sized_dynobj<size, big_endian>::read_dynsym_section( unsigned int shndx, elfcpp::SHT type, unsigned int link, - File_view** aview, + File_view** view, section_size_type* view_size, unsigned int* view_info) { if (shndx == -1U) { - *aview = NULL; + *view = NULL; *view_size = 0; *view_info = 0; return; @@ -200,8 +200,8 @@ Sized_dynobj<size, big_endian>::read_dynsym_section( this->error(_("unexpected link in section %u header: %u != %u"), shndx, this->adjust_shndx(shdr.get_sh_link()), link); - *aview = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(), - true, false); + *view = this->get_lasting_view(shdr.get_sh_offset(), shdr.get_sh_size(), + true, false); *view_size = convert_to_section_size_type(shdr.get_sh_size()); *view_info = shdr.get_sh_info(); } @@ -424,8 +424,8 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab, Layout*, Read_symbols_data* sd) { - const unsigned int sec_shnum = this->shnum(); - if (sec_shnum == 0) + const unsigned int shnum = this->shnum(); + if (shnum == 0) return; // Get the section headers. @@ -437,7 +437,7 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab, // Skip the first, dummy, section. pshdrs += This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, pshdrs += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size) { typename This::Shdr shdr(pshdrs); @@ -448,10 +448,10 @@ Sized_dynobj<size, big_endian>::do_layout(Symbol_table* symtab, return; } - const char* aname = pnames + shdr.get_sh_name(); + const char* name = pnames + shdr.get_sh_name(); - this->handle_gnu_warning_section(aname, i, symtab); - this->handle_split_stack_section(aname); + this->handle_gnu_warning_section(name, i, symtab); + this->handle_split_stack_section(name); } delete sd->section_headers; @@ -468,13 +468,13 @@ void Sized_dynobj<size, big_endian>::set_version_map( Version_map* version_map, unsigned int ndx, - const char* aname) const + const char* name) const { if (ndx >= version_map->size()) version_map->resize(ndx + 1); if ((*version_map)[ndx] != NULL) this->error(_("duplicate definition for version %u"), ndx); - (*version_map)[ndx] = aname; + (*version_map)[ndx] = name; } // Add mappings for the version definitions to VERSION_MAP. @@ -670,10 +670,10 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, return; } - const int symsize = This::sym_size; - const size_t symcount = sd->symbols_size / symsize; + const int sym_size = This::sym_size; + const size_t symcount = sd->symbols_size / sym_size; gold_assert(sd->external_symbols_offset == 0); - if (symcount * symsize != sd->symbols_size) + if (symcount * sym_size != sd->symbols_size) { this->error(_("size of dynamic symbols is not multiple of symbol size")); return; @@ -1217,9 +1217,9 @@ Verdef::write(const Stringpool* dynpool, bool is_last, unsigned char* pb) const p != this->deps_.end(); ++p, ++i) { - elfcpp::Verdaux_write<size, big_endian> avda(pb); - avda.set_vda_name(dynpool->get_offset(*p)); - avda.set_vda_next(i + 1 >= this->deps_.size() ? 0 : verdaux_size); + elfcpp::Verdaux_write<size, big_endian> vda(pb); + vda.set_vda_name(dynpool->get_offset(*p)); + vda.set_vda_next(i + 1 >= this->deps_.size() ? 0 : verdaux_size); pb += verdaux_size; } @@ -1305,10 +1305,10 @@ Verneed::write(const Stringpool* dynpool, bool is_last, // Versions methods. -Versions::Versions(const Version_script_info& vscript, +Versions::Versions(const Version_script_info& version_script, Stringpool* dynpool) : defs_(), needs_(), version_table_(), - is_finalized_(false), version_script_(vscript), + is_finalized_(false), version_script_(version_script), needs_base_version_(parameters->options().shared()) { if (!this->version_script_.empty()) @@ -1620,18 +1620,18 @@ Versions::symbol_section_contents(const Symbol_table* symtab, p != syms.end(); ++p) { - unsigned int vindex; + unsigned int version_index; const char* version = (*p)->version(); if (version == NULL) - vindex = elfcpp::VER_NDX_GLOBAL; + version_index = elfcpp::VER_NDX_GLOBAL; else - vindex = this->version_index(symtab, dynpool, *p); + version_index = this->version_index(symtab, dynpool, *p); // If the symbol was defined as foo@V1 instead of foo@@V1, add // the hidden bit. if ((*p)->version() != NULL && !(*p)->is_default()) - vindex |= elfcpp::VERSYM_HIDDEN; + version_index |= elfcpp::VERSYM_HIDDEN; elfcpp::Swap<16, big_endian>::writeval(pbuf + (*p)->dynsym_index() * 2, - vindex); + version_index); } *pp = pbuf; diff --git a/gold/dynobj.h b/gold/dynobj.h index be0d975..66d2bff 100644 --- a/gold/dynobj.h +++ b/gold/dynobj.h @@ -330,10 +330,10 @@ class Version_base // Set the version index. void - set_index(unsigned int vindex) + set_index(unsigned int index) { gold_assert(this->index_ == -1U); - this->index_ = vindex; + this->index_ = index; } // Clear the weak flag in a version definition. @@ -354,10 +354,10 @@ class Version_base class Verdef : public Version_base { public: - Verdef(const char* vname, const std::vector<std::string>& deps, - bool is_base, bool vis_weak, bool vis_symbol_created) - : name_(vname), deps_(deps), is_base_(is_base), is_weak_(vis_weak), - is_symbol_created_(vis_symbol_created) + Verdef(const char* name, const std::vector<std::string>& deps, + bool is_base, bool is_weak, bool is_symbol_created) + : name_(name), deps_(deps), is_base_(is_base), is_weak_(is_weak), + is_symbol_created_(is_symbol_created) { } // Return the version name. @@ -373,8 +373,8 @@ class Verdef : public Version_base // Add a dependency to this version. The NAME should be // canonicalized in the dynamic Stringpool. void - add_dependency(const char* dname) - { this->deps_.push_back(dname); } + add_dependency(const char* name) + { this->deps_.push_back(name); } // Return whether this definition is weak. bool @@ -424,8 +424,8 @@ class Verdef : public Version_base class Verneed_version : public Version_base { public: - Verneed_version(const char* ver) - : version_(ver) + Verneed_version(const char* version) + : version_(version) { } // Return the version name. @@ -450,8 +450,8 @@ class Verneed_version : public Version_base class Verneed { public: - Verneed(const char* fname) - : filename_(fname), need_versions_() + Verneed(const char* filename) + : filename_(filename), need_versions_() { } ~Verneed(); diff --git a/gold/ehframe.cc b/gold/ehframe.cc index a9afa1d..333e665 100644 --- a/gold/ehframe.cc +++ b/gold/ehframe.cc @@ -93,15 +93,15 @@ Eh_frame_hdr::Eh_frame_hdr(Output_section* eh_frame_section, void Eh_frame_hdr::set_final_data_size() { - unsigned int datasize = eh_frame_hdr_size + 4; + unsigned int data_size = eh_frame_hdr_size + 4; if (!this->any_unrecognized_eh_frame_sections_) { unsigned int fde_count = this->eh_frame_data_->fde_count(); if (fde_count != 0) - datasize += 4 + 8 * fde_count; + data_size += 4 + 8 * fde_count; this->fde_offsets_.reserve(fde_count); } - this->set_data_size(datasize); + this->set_data_size(data_size); } // Write the data to the flie. @@ -332,11 +332,11 @@ Fde::write(unsigned char* oview, section_offset_type offset, { gold_assert((offset & (addralign - 1)) == 0); - size_t len = this->contents_.length(); + size_t length = this->contents_.length(); // We add 8 when getting the aligned length to account for the // length word and the CIE offset. - size_t aligned_full_length = align_address(len + 8, addralign); + size_t aligned_full_length = align_address(length + 8, addralign); // Write the length of the FDE as a 32-bit word. The length word // does not include the four bytes of the length word itself, but it @@ -353,10 +353,10 @@ Fde::write(unsigned char* oview, section_offset_type offset, // Copy the rest of the FDE. Note that this is run before // relocation processing is done on this section, so the relocations // will later be applied to the FDE data. - memcpy(oview + offset + 8, this->contents_.data(), len); + memcpy(oview + offset + 8, this->contents_.data(), length); - if (aligned_full_length > len + 8) - memset(oview + offset + len + 8, 0, aligned_full_length - (len + 8)); + if (aligned_full_length > length + 8) + memset(oview + offset + length + 8, 0, aligned_full_length - (length + 8)); // Tell the exception frame header about this FDE. if (eh_frame_hdr != NULL) @@ -934,16 +934,16 @@ Eh_frame::read_fde(Sized_relobj<size, big_endian>* object, const unsigned char* symbols, section_size_type symbols_size, const unsigned char* pcontents, - unsigned int fde_offset, + unsigned int offset, const unsigned char* pfde, const unsigned char *pfdeend, Track_relocs<size, big_endian>* relocs, Offsets_to_cie* cies) { - // FDE_OFFSET is the distance between the 4 bytes before PFDE to the + // OFFSET is the distance between the 4 bytes before PFDE to the // start of the CIE. The offset we recorded for the CIE is 8 bytes // after the start of the CIE--after the length and the zero tag. - unsigned int cie_offset = (pfde - 4 - pcontents) - fde_offset + 8; + unsigned int cie_offset = (pfde - 4 - pcontents) - offset + 8; Offsets_to_cie::const_iterator pcie = cies->find(cie_offset); if (pcie == cies->end()) return false; @@ -1026,38 +1026,38 @@ Eh_frame::set_final_data_size() return; } - section_offset_type out_offset = 0; + section_offset_type output_offset = 0; for (Unmergeable_cie_offsets::iterator p = this->unmergeable_cie_offsets_.begin(); p != this->unmergeable_cie_offsets_.end(); ++p) - out_offset = (*p)->set_output_offset(out_offset, - this->addralign(), - &this->merge_map_); + output_offset = (*p)->set_output_offset(output_offset, + this->addralign(), + &this->merge_map_); for (Cie_offsets::iterator p = this->cie_offsets_.begin(); p != this->cie_offsets_.end(); ++p) - out_offset = (*p)->set_output_offset(out_offset, - this->addralign(), - &this->merge_map_); + output_offset = (*p)->set_output_offset(output_offset, + this->addralign(), + &this->merge_map_); this->mappings_are_done_ = true; - this->final_data_size_ = out_offset; + this->final_data_size_ = output_offset; - gold_assert((out_offset & (this->addralign() - 1)) == 0); - this->set_data_size(out_offset); + gold_assert((output_offset & (this->addralign() - 1)) == 0); + this->set_data_size(output_offset); } // Return an output offset for an input offset. bool Eh_frame::do_output_offset(const Relobj* object, unsigned int shndx, - section_offset_type foffset, + section_offset_type offset, section_offset_type* poutput) const { - return this->merge_map_.get_output_offset(object, shndx, foffset, poutput); + return this->merge_map_.get_output_offset(object, shndx, offset, poutput); } // Return whether this is the merge section for an input section. @@ -1074,9 +1074,9 @@ Eh_frame::do_is_merge_section_for(const Relobj* object, void Eh_frame::do_write(Output_file* of) { - const off_t foffset = this->offset(); + const off_t offset = this->offset(); const off_t oview_size = this->data_size(); - unsigned char* const oview = of->get_output_view(foffset, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); switch (parameters->size_and_endianness()) { @@ -1104,7 +1104,7 @@ Eh_frame::do_write(Output_file* of) gold_unreachable(); } - of->write_output_view(foffset, oview_size, oview); + of->write_output_view(offset, oview_size, oview); } // Write the data to the output file--template version. @@ -1113,18 +1113,18 @@ template<int size, bool big_endian> void Eh_frame::do_sized_write(unsigned char* oview) { - unsigned int addr_align = this->addralign(); + unsigned int addralign = this->addralign(); section_offset_type o = 0; for (Unmergeable_cie_offsets::iterator p = this->unmergeable_cie_offsets_.begin(); p != this->unmergeable_cie_offsets_.end(); ++p) - o = (*p)->write<size, big_endian>(oview, o, addr_align, + o = (*p)->write<size, big_endian>(oview, o, addralign, this->eh_frame_hdr_); for (Cie_offsets::iterator p = this->cie_offsets_.begin(); p != this->cie_offsets_.end(); ++p) - o = (*p)->write<size, big_endian>(oview, o, addr_align, + o = (*p)->write<size, big_endian>(oview, o, addralign, this->eh_frame_hdr_); } diff --git a/gold/ehframe.h b/gold/ehframe.h index 06d0fdc..4726ffc 100644 --- a/gold/ehframe.h +++ b/gold/ehframe.h @@ -1,6 +1,6 @@ // ehframe.h -- handle exception frame sections for gold -*- C++ -*- -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -169,9 +169,9 @@ class Fde { public: Fde(Relobj* object, unsigned int shndx, section_offset_type input_offset, - const unsigned char* contents, size_t len) + const unsigned char* contents, size_t length) : object_(object), shndx_(shndx), input_offset_(input_offset), - contents_(reinterpret_cast<const char*>(contents), len) + contents_(reinterpret_cast<const char*>(contents), length) { } // Return the length of this FDE. Add 4 for the length and 4 for diff --git a/gold/errors.cc b/gold/errors.cc index a7c3ad2..618f9cd 100644 --- a/gold/errors.cc +++ b/gold/errors.cc @@ -1,6 +1,6 @@ // errors.cc -- handle errors for gold -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -38,8 +38,8 @@ namespace gold const int Errors::max_undefined_error_report; -Errors::Errors(const char* prog_name) - : program_name_(prog_name), lock_(NULL), initialize_lock_(&this->lock_), +Errors::Errors(const char* program_name) + : program_name_(program_name), lock_(NULL), initialize_lock_(&this->lock_), error_count_(0), warning_count_(0), undefined_symbols_() { } diff --git a/gold/expression.cc b/gold/expression.cc index 8bbcfaa..853a698 100644 --- a/gold/expression.cc +++ b/gold/expression.cc @@ -1,6 +1,6 @@ // expression.cc -- expressions in linker scripts for gold -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -739,10 +739,10 @@ class Align_expression : public Binary_expression && parameters->options().relocatable()) gold_warning(_("aligning to section relative value")); - uint64_t val = this->left_value(eei, eei->result_section_pointer); + uint64_t value = this->left_value(eei, eei->result_section_pointer); if (align <= 1) - return val; - return ((val + align - 1) / align) * align; + return value; + return ((value + align - 1) / align) * align; } void @@ -768,10 +768,10 @@ class Assert_expression : public Unary_expression uint64_t value(const Expression_eval_info* eei) { - uint64_t val = this->arg_value(eei, eei->result_section_pointer); - if (!val && eei->check_assertions) + uint64_t value = this->arg_value(eei, eei->result_section_pointer); + if (!value && eei->check_assertions) gold_error("%s", this->message_.c_str()); - return val; + return value; } void diff --git a/gold/fileread.cc b/gold/fileread.cc index ebc6e23..ac30769 100644 --- a/gold/fileread.cc +++ b/gold/fileread.cc @@ -754,14 +754,14 @@ File_view::~File_view() // Create a file for testing. -Input_file::Input_file(const Task* task, const char* iname, +Input_file::Input_file(const Task* task, const char* name, const unsigned char* contents, off_t size) : file_() { this->input_argument_ = - new Input_file_argument(iname, Input_file_argument::INPUT_FILE_TYPE_FILE, + new Input_file_argument(name, Input_file_argument::INPUT_FILE_TYPE_FILE, "", false, Position_dependent_options()); - bool ok = this->file_.open(task, iname, contents, size); + bool ok = this->file_.open(task, name, contents, size); gold_assert(ok); } @@ -843,7 +843,7 @@ File_read::get_mtime() bool Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) { - std::string iname; + std::string name; // Case 1: name is an absolute file, just try to open it // Case 2: name is relative but is_lib is false, is_searched_file is false, @@ -853,8 +853,8 @@ Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) && !this->input_argument_->is_searched_file() && this->input_argument_->extra_search_path() == NULL)) { - iname = this->input_argument_->name(); - this->found_name_ = iname; + name = this->input_argument_->name(); + this->found_name_ = name; } // Case 3: is_lib is true or is_searched_file is true else if (this->input_argument_->is_lib() @@ -878,15 +878,15 @@ Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) } else n1 = this->input_argument_->name(); - iname = dirpath.find(n1, n2, &this->is_in_sysroot_, pindex); - if (iname.empty()) + name = dirpath.find(n1, n2, &this->is_in_sysroot_, pindex); + if (name.empty()) { gold_error(_("cannot find %s%s"), this->input_argument_->is_lib() ? "-l" : "", this->input_argument_->name()); return false; } - if (n2.empty() || iname[iname.length() - 1] == 'o') + if (n2.empty() || name[name.length() - 1] == 'o') this->found_name_ = n1; else this->found_name_ = n2; @@ -897,20 +897,20 @@ Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) gold_assert(this->input_argument_->extra_search_path() != NULL); // First, check extra_search_path. - iname = this->input_argument_->extra_search_path(); - if (!IS_DIR_SEPARATOR (iname[iname.length() - 1])) - iname += '/'; - iname += this->input_argument_->name(); + name = this->input_argument_->extra_search_path(); + if (!IS_DIR_SEPARATOR (name[name.length() - 1])) + name += '/'; + name += this->input_argument_->name(); struct stat dummy_stat; - if (*pindex > 0 || ::stat(iname.c_str(), &dummy_stat) < 0) + if (*pindex > 0 || ::stat(name.c_str(), &dummy_stat) < 0) { // extra_search_path failed, so check the normal search-path. int index = *pindex; if (index > 0) --index; - iname = dirpath.find(this->input_argument_->name(), "", - &this->is_in_sysroot_, &index); - if (iname.empty()) + name = dirpath.find(this->input_argument_->name(), "", + &this->is_in_sysroot_, &index); + if (name.empty()) { gold_error(_("cannot find %s"), this->input_argument_->name()); @@ -927,17 +927,17 @@ Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) this->input_argument_->options().format_enum(); bool ok; if (format == General_options::OBJECT_FORMAT_ELF) - ok = this->file_.open(task, iname); + ok = this->file_.open(task, name); else { gold_assert(format == General_options::OBJECT_FORMAT_BINARY); - ok = this->open_binary(task, iname); + ok = this->open_binary(task, name); } if (!ok) { gold_error(_("cannot open %s: %s"), - iname.c_str(), strerror(errno)); + name.c_str(), strerror(errno)); return false; } @@ -947,7 +947,7 @@ Input_file::open(const Dirsearch& dirpath, const Task* task, int *pindex) // Open a file for --format binary. bool -Input_file::open_binary(const Task* task, const std::string& iname) +Input_file::open_binary(const Task* task, const std::string& name) { // In order to open a binary file, we need machine code, size, and // endianness. We may not have a valid target at this point, in @@ -958,10 +958,10 @@ Input_file::open_binary(const Task* task, const std::string& iname) Binary_to_elf binary_to_elf(target.machine_code(), target.get_size(), target.is_big_endian(), - iname); + name); if (!binary_to_elf.convert(task)) return false; - return this->file_.open(task, iname, binary_to_elf.converted_data_leak(), + return this->file_.open(task, name, binary_to_elf.converted_data_leak(), binary_to_elf.converted_size()); } diff --git a/gold/fileread.h b/gold/fileread.h index 2e27d2f..47c8e0f 100644 --- a/gold/fileread.h +++ b/gold/fileread.h @@ -246,10 +246,10 @@ class File_read DATA_MMAPPED }; - View(off_t vstart, section_size_type vsize, const unsigned char* vdata, - unsigned int vbyteshift, bool cache, Data_ownership data_ownership) - : start_(vstart), size_(vsize), data_(vdata), lock_count_(0), - byteshift_(vbyteshift), cache_(cache), data_ownership_(data_ownership), + View(off_t start, section_size_type size, const unsigned char* data, + unsigned int byteshift, bool cache, Data_ownership data_ownership) + : start_(start), size_(size), data_(data), lock_count_(0), + byteshift_(byteshift), cache_(cache), data_ownership_(data_ownership), accessed_(true) { } @@ -450,8 +450,8 @@ class File_view friend class File_read; // Callers have to get these via File_read::get_lasting_view. - File_view(File_read& file, File_read::View* view, const unsigned char* vdata) - : file_(file), view_(view), data_(vdata) + File_view(File_read& file, File_read::View* view, const unsigned char* data) + : file_(file), view_(view), data_(data) { } File_read& file_; diff --git a/gold/freebsd.h b/gold/freebsd.h index 9dbebe7..de69735 100644 --- a/gold/freebsd.h +++ b/gold/freebsd.h @@ -87,11 +87,11 @@ Target_freebsd<size, big_endian>::do_adjust_elf_header(unsigned char* view, class Target_selector_freebsd : public Target_selector { public: - Target_selector_freebsd(int amachine, int size, bool is_big_end, - const char* bfdname, + Target_selector_freebsd(int machine, int size, bool is_big_endian, + const char* bfd_name, const char* freebsd_bfd_name) - : Target_selector(amachine, size, is_big_end, NULL), - bfd_name_(bfdname), freebsd_bfd_name_(freebsd_bfd_name) + : Target_selector(machine, size, is_big_endian, NULL), + bfd_name_(bfd_name), freebsd_bfd_name_(freebsd_bfd_name) { } protected: diff --git a/gold/i386.cc b/gold/i386.cc index cadffba..4820f15 100644 --- a/gold/i386.cc +++ b/gold/i386.cc @@ -667,10 +667,10 @@ unsigned char Output_data_plt_i386::dyn_plt_entry[plt_entry_size] = void Output_data_plt_i386::do_write(Output_file* of) { - const off_t off = this->offset(); + const off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); const off_t got_file_offset = this->got_plt_->offset(); const section_size_type got_size = @@ -739,7 +739,7 @@ Output_data_plt_i386::do_write(Output_file* of) gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); of->write_output_view(got_file_offset, got_size, got_view); } @@ -975,7 +975,7 @@ Target_i386::Scan::local(Symbol_table* symtab, if (parameters->options().output_is_position_independent()) { Reloc_section* rel_dyn = target->rel_dyn_section(layout); - r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); + unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info()); rel_dyn->add_local_relative( object, r_sym, elfcpp::R_386_RELATIVE, got, object->local_got_offset(r_sym, GOT_TYPE_STANDARD)); diff --git a/gold/icf.cc b/gold/icf.cc index 39334a5..03b927a 100644 --- a/gold/icf.cc +++ b/gold/icf.cc @@ -557,7 +557,7 @@ Icf::find_identical_sections(const Input_objects* input_objects, Symbol_table* symtab) { unsigned int section_num = 0; - std::vector<unsigned int> num_tracked_rels; + std::vector<unsigned int> num_tracked_relocs; std::vector<bool> is_secn_or_group_unique; std::vector<std::string> section_contents; @@ -585,7 +585,7 @@ Icf::find_identical_sections(const Input_objects* input_objects, this->id_section_.push_back(Section_id(*p, i)); this->section_id_[Section_id(*p, i)] = section_num; this->kept_section_id_.push_back(section_num); - num_tracked_rels.push_back(0); + num_tracked_relocs.push_back(0); is_secn_or_group_unique.push_back(false); section_contents.push_back(""); section_num++; @@ -605,7 +605,7 @@ Icf::find_identical_sections(const Input_objects* input_objects, { num_iterations++; converged = match_sections(num_iterations, symtab, - &num_tracked_rels, &this->kept_section_id_, + &num_tracked_relocs, &this->kept_section_id_, this->id_section_, &is_secn_or_group_unique, §ion_contents); } diff --git a/gold/incremental.h b/gold/incremental.h index 58b5895..a94f397 100644 --- a/gold/incremental.h +++ b/gold/incremental.h @@ -432,8 +432,8 @@ class Incremental_inputs // Record the input arguments obtained from parsing the command line. void - report_inputs(const Input_arguments& ins) - { this->inputs_ = &ins; } + report_inputs(const Input_arguments& inputs) + { this->inputs_ = &inputs; } // Record that the input argument INPUT is an archive ARCHIVE. void diff --git a/gold/layout.cc b/gold/layout.cc index 8655e7c..a7f8185 100644 --- a/gold/layout.cc +++ b/gold/layout.cc @@ -160,9 +160,9 @@ Layout_task_runner::run(Workqueue* workqueue, const Task* task) // Layout methods. -Layout::Layout(int number_of_input_files, Script_options* script_opts) +Layout::Layout(int number_of_input_files, Script_options* script_options) : number_of_input_files_(number_of_input_files), - script_options_(script_opts), + script_options_(script_options), namepool_(), sympool_(), dynpool_(), @@ -2831,7 +2831,7 @@ Layout::create_dynamic_symtab(const Input_objects* input_objects, // inconvenient to check. if (this->allocated_output_section_count() >= elfcpp::SHN_LORESERVE) { - Output_section* dyn_sym_xindex = + Output_section* dynsym_xindex = this->choose_output_section(NULL, ".dynsym_shndx", elfcpp::SHT_SYMTAB_SHNDX, elfcpp::SHF_ALLOC, @@ -2839,13 +2839,13 @@ Layout::create_dynamic_symtab(const Input_objects* input_objects, this->dynsym_xindex_ = new Output_symtab_xindex(index); - dyn_sym_xindex->add_output_section_data(this->dynsym_xindex_); + dynsym_xindex->add_output_section_data(this->dynsym_xindex_); - dyn_sym_xindex->set_link_section(dynsym); - dyn_sym_xindex->set_addralign(4); - dyn_sym_xindex->set_entsize(4); + dynsym_xindex->set_link_section(dynsym); + dynsym_xindex->set_addralign(4); + dynsym_xindex->set_entsize(4); - dyn_sym_xindex->set_after_input_sections(); + dynsym_xindex->set_after_input_sections(); // This tells the driver code to wait until the symbol table has // written out before writing out the postprocessing sections, @@ -3489,13 +3489,13 @@ Layout::find_or_add_kept_section(const std::string& name, // Store the allocated sections into the section list. void -Layout::get_allocated_sections(Section_list* sec_list) const +Layout::get_allocated_sections(Section_list* section_list) const { for (Section_list::const_iterator p = this->section_list_.begin(); p != this->section_list_.end(); ++p) if (((*p)->flags() & elfcpp::SHF_ALLOC) != 0) - sec_list->push_back(*p); + section_list->push_back(*p); } // Create an output segment. @@ -3538,35 +3538,35 @@ Layout::write_data(const Symbol_table* symtab, Output_file* of) const { if (!parameters->options().strip_all()) { - const Output_section* sym_tab_section = this->symtab_section_; + const Output_section* symtab_section = this->symtab_section_; for (Section_list::const_iterator p = this->section_list_.begin(); p != this->section_list_.end(); ++p) { if ((*p)->needs_symtab_index()) { - gold_assert(sym_tab_section != NULL); + gold_assert(symtab_section != NULL); unsigned int index = (*p)->symtab_index(); gold_assert(index > 0 && index != -1U); - off_t off = (sym_tab_section->offset() - + index * sym_tab_section->entsize()); + off_t off = (symtab_section->offset() + + index * symtab_section->entsize()); symtab->write_section_symbol(*p, this->symtab_xindex_, of, off); } } } - const Output_section* dyn_sym_section = this->dynsym_section_; + const Output_section* dynsym_section = this->dynsym_section_; for (Section_list::const_iterator p = this->section_list_.begin(); p != this->section_list_.end(); ++p) { if ((*p)->needs_dynsym_index()) { - gold_assert(dyn_sym_section != NULL); + gold_assert(dynsym_section != NULL); unsigned int index = (*p)->dynsym_index(); gold_assert(index > 0 && index != -1U); - off_t off = (dyn_sym_section->offset() - + index * dyn_sym_section->entsize()); + off_t off = (dynsym_section->offset() + + index * dynsym_section->entsize()); symtab->write_section_symbol(*p, this->dynsym_xindex_, of, off); } } diff --git a/gold/layout.h b/gold/layout.h index 79785bf..71afa96 100644 --- a/gold/layout.h +++ b/gold/layout.h @@ -151,10 +151,10 @@ class Kept_section // Set the object. void - set_object(Relobj* obj) + set_object(Relobj* object) { gold_assert(this->object_ == NULL); - this->object_ = obj; + this->object_ = object; } // The section index. @@ -164,10 +164,10 @@ class Kept_section // Set the section index. void - set_shndx(unsigned int sec_shndx) + set_shndx(unsigned int shndx) { gold_assert(this->shndx_ == 0); - this->shndx_ = sec_shndx; + this->shndx_ = shndx; } // Whether this is a comdat group. @@ -198,11 +198,11 @@ class Kept_section // Add a section to the group list. void - add_comdat_section(const std::string& name, unsigned int sec_shndx, + add_comdat_section(const std::string& name, unsigned int shndx, uint64_t size) { gold_assert(this->is_comdat_); - Comdat_section_info sinfo(sec_shndx, size); + Comdat_section_info sinfo(shndx, size); this->u_.group_sections->insert(std::make_pair(name, sinfo)); } diff --git a/gold/mapfile.cc b/gold/mapfile.cc index a9b4e72..a3ba52b 100644 --- a/gold/mapfile.cc +++ b/gold/mapfile.cc @@ -217,7 +217,7 @@ Mapfile::print_input_section_symbols( && is_ordinary && sym->is_defined()) { - for (size_t j = 0; j < Mapfile::section_name_map_length; ++j) + for (size_t i = 0; i < Mapfile::section_name_map_length; ++i) putc(' ', this->map_file_); const Sized_symbol<size>* ssym = static_cast<const Sized_symbol<size>*>(sym); diff --git a/gold/merge.cc b/gold/merge.cc index 654f349..3d96921 100644 --- a/gold/merge.cc +++ b/gold/merge.cc @@ -289,10 +289,10 @@ Merge_map::is_merge_section_for(const Relobj* object, unsigned int shndx) const bool Output_merge_base::do_output_offset(const Relobj* object, unsigned int shndx, - section_offset_type off, + section_offset_type offset, section_offset_type* poutput) const { - return this->merge_map_.get_output_offset(object, shndx, off, poutput); + return this->merge_map_.get_output_offset(object, shndx, offset, poutput); } // Return whether this is the merge section for SHNDX in OBJECT. @@ -354,10 +354,10 @@ Output_merge_data::Merge_data_eq::operator()(Merge_data_key k1, void Output_merge_data::add_constant(const unsigned char* p) { - section_size_type ent_size = convert_to_section_size_type(this->entsize()); - section_size_type addr_align = + section_size_type entsize = convert_to_section_size_type(this->entsize()); + section_size_type addralign = convert_to_section_size_type(this->addralign()); - section_size_type addsize = std::max(ent_size, addr_align); + section_size_type addsize = std::max(entsize, addralign); if (this->len_ + addsize > this->alc_) { if (this->alc_ == 0) @@ -369,9 +369,9 @@ Output_merge_data::add_constant(const unsigned char* p) gold_nomem(); } - memcpy(this->p_ + this->len_, p, ent_size); - if (addsize > ent_size) - memset(this->p_ + this->len_ + ent_size, 0, addsize - ent_size); + memcpy(this->p_ + this->len_, p, entsize); + if (addsize > entsize) + memset(this->p_ + this->len_ + entsize, 0, addsize - entsize); this->len_ += addsize; } @@ -386,14 +386,14 @@ Output_merge_data::do_add_input_section(Relobj* object, unsigned int shndx) section_size_type len; const unsigned char* p = object->section_contents(shndx, &len, false); - section_size_type ent_size = convert_to_section_size_type(this->entsize()); + section_size_type entsize = convert_to_section_size_type(this->entsize()); - if (len % ent_size != 0) + if (len % entsize != 0) return false; - this->input_count_ += len / ent_size; + this->input_count_ += len / entsize; - for (section_size_type i = 0; i < len; i += ent_size, p += ent_size) + for (section_size_type i = 0; i < len; i += entsize, p += entsize) { // Add the constant to the section contents. If we find that it // is already in the hash table, we will remove it again. @@ -406,12 +406,12 @@ Output_merge_data::do_add_input_section(Relobj* object, unsigned int shndx) if (!ins.second) { // Key was already present. Remove the copy we just added. - this->len_ -= ent_size; + this->len_ -= entsize; k = *ins.first; } // Record the offset of this constant in the output section. - this->add_mapping(object, shndx, i, ent_size, k); + this->add_mapping(object, shndx, i, entsize, k); } return true; @@ -531,9 +531,9 @@ Output_merge_string<Char_type>::finalize_merged_data() p != this->merged_strings_.end(); ++p) { - section_offset_type soffset = + section_offset_type offset = this->stringpool_.get_offset_from_key(p->stringpool_key); - this->add_mapping(p->object, p->shndx, p->offset, p->length, soffset); + this->add_mapping(p->object, p->shndx, p->offset, p->length, offset); } // Save some memory. This also ensures that this function will work diff --git a/gold/merge.h b/gold/merge.h index 62c0eca..345b115 100644 --- a/gold/merge.h +++ b/gold/merge.h @@ -1,6 +1,6 @@ // merge.h -- handle section merging for gold -*- C++ -*- -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -215,8 +215,8 @@ class Merge_map class Output_merge_base : public Output_section_data { public: - Output_merge_base(uint64_t ent_size, uint64_t addr_align) - : Output_section_data(addr_align), merge_map_(), entsize_(ent_size) + Output_merge_base(uint64_t entsize, uint64_t addralign) + : Output_section_data(addralign), merge_map_(), entsize_(entsize) { } // Return the entry size. @@ -241,15 +241,15 @@ class Output_merge_base : public Output_section_data bool do_is_merge_section_for(const Relobj*, unsigned int shndx) const; - // Add a mapping from an IN_OFFSET in input section SHNDX in object - // OBJECT to an OUT_OFFSET in the output section. OUT_OFFSET + // Add a mapping from an OFFSET in input section SHNDX in object + // OBJECT to an OUTPUT_OFFSET in the output section. OUTPUT_OFFSET // is the offset from the start of the merged data in the output // section. void - add_mapping(Relobj* object, unsigned int shndx, section_offset_type in_offset, - section_size_type length, section_offset_type out_offset) + add_mapping(Relobj* object, unsigned int shndx, section_offset_type offset, + section_size_type length, section_offset_type output_offset) { - this->merge_map_.add_mapping(object, shndx, in_offset, length, out_offset); + this->merge_map_.add_mapping(object, shndx, offset, length, output_offset); } // This may be overriden by the child class. @@ -271,8 +271,8 @@ class Output_merge_base : public Output_section_data class Output_merge_data : public Output_merge_base { public: - Output_merge_data(uint64_t ent_size, uint64_t addr_align) - : Output_merge_base(ent_size, addr_align), p_(NULL), len_(0), alc_(0), + Output_merge_data(uint64_t entsize, uint64_t addralign) + : Output_merge_base(entsize, addralign), p_(NULL), len_(0), alc_(0), input_count_(0), hashtable_(128, Merge_data_hash(this), Merge_data_eq(this)) { } @@ -386,11 +386,11 @@ template<typename Char_type> class Output_merge_string : public Output_merge_base { public: - Output_merge_string(uint64_t addr_align) - : Output_merge_base(sizeof(Char_type), addr_align), stringpool_(), + Output_merge_string(uint64_t addralign) + : Output_merge_base(sizeof(Char_type), addralign), stringpool_(), merged_strings_(), input_count_(0) { - gold_assert(addr_align <= sizeof(Char_type)); + gold_assert(addralign <= sizeof(Char_type)); this->stringpool_.set_no_zero_null(); } diff --git a/gold/object.cc b/gold/object.cc index 465e99c..798e42d 100644 --- a/gold/object.cc +++ b/gold/object.cc @@ -51,12 +51,12 @@ namespace gold template<int size, bool big_endian> void -Xindex::initialize_symtab_xindex(Object* object, unsigned int sym_tab_shndx) +Xindex::initialize_symtab_xindex(Object* object, unsigned int symtab_shndx) { if (!this->symtab_xindex_.empty()) return; - gold_assert(sym_tab_shndx != 0); + gold_assert(symtab_shndx != 0); // Look through the sections in reverse order, on the theory that it // is more likely to be near the end than the beginning. @@ -65,7 +65,7 @@ Xindex::initialize_symtab_xindex(Object* object, unsigned int sym_tab_shndx) { --i; if (object->section_type(i) == elfcpp::SHT_SYMTAB_SHNDX - && this->adjust_shndx(object->section_link(i)) == sym_tab_shndx) + && this->adjust_shndx(object->section_link(i)) == symtab_shndx) { this->read_symtab_xindex<size, big_endian>(object, i, NULL); return; @@ -177,8 +177,8 @@ Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file, // Read the section headers. const off_t shoff = elf_file->shoff(); - const unsigned int sec_shnum = this->shnum(); - sd->section_headers = this->get_lasting_view(shoff, sec_shnum * shdr_size, + const unsigned int shnum = this->shnum(); + sd->section_headers = this->get_lasting_view(shoff, shnum * shdr_size, true, true); // Read the section names. @@ -197,17 +197,17 @@ Object::read_section_data(elfcpp::Elf_file<size, big_endian, Object>* elf_file, false); } -// If SNAME is the name of a special .gnu.warning section, arrange for +// If NAME is the name of a special .gnu.warning section, arrange for // the warning to be issued. SHNDX is the section index. Return // whether it is a warning section. bool -Object::handle_gnu_warning_section(const char* sname, unsigned int shndx, +Object::handle_gnu_warning_section(const char* name, unsigned int shndx, Symbol_table* symtab) { const char warn_prefix[] = ".gnu.warning."; const int warn_prefix_len = sizeof warn_prefix - 1; - if (strncmp(sname, warn_prefix, warn_prefix_len) == 0) + if (strncmp(name, warn_prefix, warn_prefix_len) == 0) { // Read the section contents to get the warning text. It would // be nicer if we only did this if we have to actually issue a @@ -220,29 +220,29 @@ Object::handle_gnu_warning_section(const char* sname, unsigned int shndx, false); if (len == 0) { - const char* warning = sname + warn_prefix_len; + const char* warning = name + warn_prefix_len; contents = reinterpret_cast<const unsigned char*>(warning); len = strlen(warning); } std::string warning(reinterpret_cast<const char*>(contents), len); - symtab->add_warning(sname + warn_prefix_len, this, warning); + symtab->add_warning(name + warn_prefix_len, this, warning); return true; } return false; } -// If SNAME is the name of the special section which indicates that +// If NAME is the name of the special section which indicates that // this object was compiled with -fstack-split, mark it accordingly. bool -Object::handle_split_stack_section(const char* sname) +Object::handle_split_stack_section(const char* name) { - if (strcmp(sname, ".note.GNU-split-stack") == 0) + if (strcmp(name, ".note.GNU-split-stack") == 0) { this->uses_split_stack_ = true; return true; } - if (strcmp(sname, ".note.GNU-no-split-stack") == 0) + if (strcmp(name, ".note.GNU-no-split-stack") == 0) { this->has_no_split_stack_ = true; return true; @@ -301,22 +301,22 @@ Relobj::copy_symbols_data(Symbols_data* gc_sd, Read_symbols_data* sd, // roots of the worklist. bool -Relobj::is_section_name_included(const char* sname) +Relobj::is_section_name_included(const char* name) { - if (is_prefix_of(".ctors", sname) - || is_prefix_of(".dtors", sname) - || is_prefix_of(".note", sname) - || is_prefix_of(".init", sname) - || is_prefix_of(".fini", sname) - || is_prefix_of(".gcc_except_table", sname) - || is_prefix_of(".jcr", sname) - || is_prefix_of(".preinit_array", sname) - || (is_prefix_of(".text", sname) - && strstr(sname, "personality")) - || (is_prefix_of(".data", sname) - && strstr(sname, "personality")) - || (is_prefix_of(".gnu.linkonce.d", sname) - && strstr(sname, "personality"))) + if (is_prefix_of(".ctors", name) + || is_prefix_of(".dtors", name) + || is_prefix_of(".note", name) + || is_prefix_of(".init", name) + || is_prefix_of(".fini", name) + || is_prefix_of(".gcc_except_table", name) + || is_prefix_of(".jcr", name) + || is_prefix_of(".preinit_array", name) + || (is_prefix_of(".text", name) + && strstr(name, "personality")) + || (is_prefix_of(".data", name) + && strstr(name, "personality")) + || (is_prefix_of(".gnu.linkonce.d", name) && + strstr(name, "personality"))) { return true; } @@ -327,11 +327,11 @@ Relobj::is_section_name_included(const char* sname) template<int size, bool big_endian> Sized_relobj<size, big_endian>::Sized_relobj( - const std::string& aname, - Input_file* ainput_file, - off_t aoffset, + const std::string& name, + Input_file* input_file, + off_t offset, const elfcpp::Ehdr<size, big_endian>& ehdr) - : Relobj(aname, ainput_file, aoffset), + : Relobj(name, input_file, offset), elf_file_(this, ehdr), symtab_shndx_(-1U), local_symbol_count_(0), @@ -361,8 +361,8 @@ template<int size, bool big_endian> void Sized_relobj<size, big_endian>::do_setup() { - const unsigned int sec_shnum = this->elf_file_.shnum(); - this->set_shnum(sec_shnum); + const unsigned int shnum = this->elf_file_.shnum(); + this->set_shnum(shnum); } // Find the SHT_SYMTAB section, given the section headers. The ELF @@ -374,14 +374,14 @@ template<int size, bool big_endian> void Sized_relobj<size, big_endian>::find_symtab(const unsigned char* pshdrs) { - const unsigned int sec_shnum = this->shnum(); + const unsigned int shnum = this->shnum(); this->symtab_shndx_ = 0; - if (sec_shnum > 0) + if (shnum > 0) { // Look through the sections in reverse order, since gas tends // to put the symbol table at the end. - const unsigned char* p = pshdrs + sec_shnum * This::shdr_size; - unsigned int i = sec_shnum; + const unsigned char* p = pshdrs + shnum * This::shdr_size; + unsigned int i = shnum; unsigned int xindex_shndx = 0; unsigned int xindex_link = 0; while (i > 0) @@ -451,9 +451,9 @@ Sized_relobj<size, big_endian>::find_eh_frame( const char* names, section_size_type names_size) const { - const unsigned int sec_shnum = this->shnum(); + const unsigned int shnum = this->shnum(); const unsigned char* p = pshdrs + This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, p += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) { typename This::Shdr shdr(p); if (this->check_eh_frame_flags(&shdr)) @@ -465,8 +465,8 @@ Sized_relobj<size, big_endian>::find_eh_frame( continue; } - const char* aname = names + shdr.get_sh_name(); - if (strcmp(aname, ".eh_frame") == 0) + const char* name = names + shdr.get_sh_name(); + if (strcmp(name, ".eh_frame") == 0) return true; } } @@ -517,11 +517,11 @@ Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd) // object file format is over 5 pages that we don't need to read // now. - const int symsize = This::sym_size; + const int sym_size = This::sym_size; const unsigned int loccount = symtabshdr.get_sh_info(); this->local_symbol_count_ = loccount; this->local_values_.resize(loccount); - section_offset_type locsize = loccount * symsize; + section_offset_type locsize = loccount * sym_size; off_t dataoff = symtabshdr.get_sh_offset(); section_size_type datasize = convert_to_section_size_type(symtabshdr.get_sh_size()); @@ -604,9 +604,9 @@ template<int size, bool big_endian> bool Sized_relobj<size, big_endian>::include_section_group( Symbol_table* symtab, - Layout* alayout, + Layout* layout, unsigned int index, - const char* aname, + const char* name, const unsigned char* shdrs, const char* section_names, section_size_type section_names_size, @@ -697,9 +697,9 @@ Sized_relobj<size, big_endian>::include_section_group( } else { - include_group = alayout->find_or_add_kept_section(signature, - this, index, true, - true, &kept_section); + include_group = layout->find_or_add_kept_section(signature, + this, index, true, + true, &kept_section); is_comdat = true; } @@ -792,8 +792,8 @@ Sized_relobj<size, big_endian>::include_section_group( } if (relocate_group) - alayout->layout_group(symtab, this, index, aname, signature.c_str(), - shdr, flags, &shndxes); + layout->layout_group(symtab, this, index, name, signature.c_str(), + shdr, flags, &shndxes); return include_group; } @@ -816,9 +816,9 @@ Sized_relobj<size, big_endian>::include_section_group( template<int size, bool big_endian> bool Sized_relobj<size, big_endian>::include_linkonce_section( - Layout* alayout, + Layout* layout, unsigned int index, - const char* aname, + const char* name, const elfcpp::Shdr<size, big_endian>& shdr) { typename elfcpp::Elf_types<size>::Elf_WXword sh_size = shdr.get_sh_size(); @@ -832,18 +832,18 @@ Sized_relobj<size, big_endian>::include_linkonce_section( // ".gnu.linkonce.d.rel.ro.local". const char* const linkonce_t = ".gnu.linkonce.t."; const char* symname; - if (strncmp(aname, linkonce_t, strlen(linkonce_t)) == 0) - symname = aname + strlen(linkonce_t); + if (strncmp(name, linkonce_t, strlen(linkonce_t)) == 0) + symname = name + strlen(linkonce_t); else - symname = strrchr(aname, '.') + 1; + symname = strrchr(name, '.') + 1; std::string sig1(symname); - std::string sig2(aname); + std::string sig2(name); Kept_section* kept1; Kept_section* kept2; - bool include1 = alayout->find_or_add_kept_section(sig1, this, index, false, - false, &kept1); - bool include2 = alayout->find_or_add_kept_section(sig2, this, index, false, - true, &kept2); + bool include1 = layout->find_or_add_kept_section(sig1, this, index, false, + false, &kept1); + bool include2 = layout->find_or_add_kept_section(sig2, this, index, false, + true, &kept2); if (!include2) { @@ -887,27 +887,27 @@ Sized_relobj<size, big_endian>::include_linkonce_section( template<int size, bool big_endian> inline void -Sized_relobj<size, big_endian>::layout_section(Layout* alayout, +Sized_relobj<size, big_endian>::layout_section(Layout* layout, unsigned int shndx, - const char* aname, + const char* name, typename This::Shdr& shdr, unsigned int reloc_shndx, unsigned int reloc_type) { - off_t aoffset; - Output_section* os = alayout->layout(this, shndx, aname, shdr, - reloc_shndx, reloc_type, &aoffset); + off_t offset; + Output_section* os = layout->layout(this, shndx, name, shdr, + reloc_shndx, reloc_type, &offset); this->output_sections()[shndx] = os; - if (aoffset == -1) + if (offset == -1) this->section_offsets_[shndx] = invalid_address; else - this->section_offsets_[shndx] = convert_types<Address, off_t>(aoffset); + this->section_offsets_[shndx] = convert_types<Address, off_t>(offset); // If this section requires special handling, and if there are // relocs that apply to it, then we must do the special handling // before we apply the relocs. - if (aoffset == -1 && reloc_shndx != 0) + if (offset == -1 && reloc_shndx != 0) this->set_relocs_must_follow_section_writes(); } @@ -928,10 +928,10 @@ Sized_relobj<size, big_endian>::layout_section(Layout* alayout, template<int size, bool big_endian> void Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_symbols_data* sd) { - const unsigned int sec_shnum = this->shnum(); + const unsigned int shnum = this->shnum(); bool is_gc_pass_one = ((parameters->options().gc_sections() && !symtab->gc()->is_worklist_ready()) || (parameters->options().icf_enabled() @@ -948,7 +948,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // Both is_gc_pass_one and is_gc_pass_two should not be true. gold_assert(!(is_gc_pass_one && is_gc_pass_two)); - if (sec_shnum == 0) + if (shnum == 0) return; Symbols_data* gc_sd = NULL; if (is_gc_pass_one) @@ -956,7 +956,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // During garbage collection save the symbols data to use it when // re-entering this function. gc_sd = new Symbols_data; - this->copy_symbols_data(gc_sd, sd, This::shdr_size * sec_shnum); + this->copy_symbols_data(gc_sd, sd, This::shdr_size * shnum); this->set_symbols_data(gc_sd); } else if (is_gc_pass_two) @@ -1016,11 +1016,11 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // For each section, record the index of the reloc section if any. // Use 0 to mean that there is no reloc section, -1U to mean that // there is more than one. - std::vector<unsigned int> reloc_shndx(sec_shnum, 0); - std::vector<unsigned int> reloc_type(sec_shnum, elfcpp::SHT_NULL); + std::vector<unsigned int> reloc_shndx(shnum, 0); + std::vector<unsigned int> reloc_type(shnum, elfcpp::SHT_NULL); // Skip the first, dummy, section. pshdrs = shdrs + This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, pshdrs += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size) { typename This::Shdr shdr(pshdrs); @@ -1032,7 +1032,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, if (sh_type == elfcpp::SHT_REL || sh_type == elfcpp::SHT_RELA) { unsigned int target_shndx = this->adjust_shndx(shdr.get_sh_info()); - if (target_shndx == 0 || target_shndx >= sec_shnum) + if (target_shndx == 0 || target_shndx >= shnum) { this->error(_("relocation section %u has bad info %u"), i, target_shndx); @@ -1054,8 +1054,8 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, if (!is_gc_pass_two) { - out_sections.resize(sec_shnum); - out_section_offsets.resize(sec_shnum); + out_sections.resize(shnum); + out_section_offsets.resize(shnum); } // If we are only linking for symbols, then there is nothing else to @@ -1084,12 +1084,12 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, uint64_t gnu_stack_flags = 0; // Keep track of which sections to omit. - std::vector<bool> omit(sec_shnum, false); + std::vector<bool> omit(shnum, false); // Keep track of reloc sections when emitting relocations. const bool relocatable = parameters->options().relocatable(); - const bool emit_rels = (relocatable - || parameters->options().emit_relocs()); + const bool emit_relocs = (relocatable + || parameters->options().emit_relocs()); std::vector<unsigned int> reloc_sections; // Keep track of .eh_frame sections. @@ -1097,7 +1097,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // Skip the first, dummy, section. pshdrs = shdrs + This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, pshdrs += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, pshdrs += This::shdr_size) { typename This::Shdr shdr(pshdrs); @@ -1108,11 +1108,11 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, return; } - const char* sname = pnames + shdr.get_sh_name(); + const char* name = pnames + shdr.get_sh_name(); if (!is_gc_pass_two) { - if (this->handle_gnu_warning_section(sname, i, symtab)) + if (this->handle_gnu_warning_section(name, i, symtab)) { if (!relocatable) omit[i] = true; @@ -1121,7 +1121,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // The .note.GNU-stack section is special. It gives the // protection flags that this object file requires for the stack // in memory. - if (strcmp(sname, ".note.GNU-stack") == 0) + if (strcmp(name, ".note.GNU-stack") == 0) { seen_gnu_stack = true; gnu_stack_flags |= shdr.get_sh_flags(); @@ -1131,7 +1131,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // The .note.GNU-split-stack section is also special. It // indicates that the object was compiled with // -fsplit-stack. - if (this->handle_split_stack_section(sname)) + if (this->handle_split_stack_section(name)) { if (!parameters->options().relocatable() && !parameters->options().shared()) @@ -1139,7 +1139,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, } // Skip attributes section. - if (parameters->target().is_attributes_section(sname)) + if (parameters->target().is_attributes_section(name)) { omit[i] = true; } @@ -1149,16 +1149,16 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, { if (shdr.get_sh_type() == elfcpp::SHT_GROUP) { - if (!this->include_section_group(symtab, alayout, i, sname, + if (!this->include_section_group(symtab, layout, i, name, shdrs, pnames, section_names_size, &omit)) discard = true; } else if ((shdr.get_sh_flags() & elfcpp::SHF_GROUP) == 0 - && Layout::is_linkonce(sname)) + && Layout::is_linkonce(name)) { - if (!this->include_linkonce_section(alayout, i, sname, shdr)) + if (!this->include_linkonce_section(layout, i, name, shdr)) discard = true; } } @@ -1174,7 +1174,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, if (is_gc_pass_one && parameters->options().gc_sections()) { - if (is_section_name_included(sname) + if (is_section_name_included(name) || shdr.get_sh_type() == elfcpp::SHT_INIT_ARRAY || shdr.get_sh_type() == elfcpp::SHT_FINI_ARRAY) { @@ -1188,7 +1188,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // However, we don't know that yet for all sections. So save // reloc sections and process them later. Garbage collection is // not triggered when relocatable code is desired. - if (emit_rels + if (emit_relocs && (shdr.get_sh_type() == elfcpp::SHT_REL || shdr.get_sh_type() == elfcpp::SHT_RELA)) { @@ -1206,7 +1206,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, // determine which sections are being discarded, and discard the // corresponding information. if (!relocatable - && strcmp(sname, ".eh_frame") == 0 + && strcmp(name, ".eh_frame") == 0 && this->check_eh_frame_flags(&shdr)) { if (is_gc_pass_one) @@ -1279,7 +1279,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, if (should_defer_layout && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC)) { gold_assert(!is_gc_pass_two); - this->deferred_layout_.push_back(Deferred_layout(i, sname, + this->deferred_layout_.push_back(Deferred_layout(i, name, pshdrs, reloc_shndx[i], reloc_type[i])); @@ -1308,18 +1308,18 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, { // When garbage collection is switched on the actual layout // only happens in the second call. - this->layout_section(alayout, i, sname, shdr, reloc_shndx[i], + this->layout_section(layout, i, name, shdr, reloc_shndx[i], reloc_type[i]); } } if (!is_gc_pass_one) - alayout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags); + layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags); // When doing a relocatable link handle the reloc sections at the // end. Garbage collection and Identical Code Folding is not // turned on for relocatable code. - if (emit_rels) + if (emit_relocs) this->size_relocatable_relocs(); gold_assert(!(is_gc_or_icf) || reloc_sections.empty()); @@ -1334,7 +1334,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, typename This::Shdr shdr(pshdr); unsigned int data_shndx = this->adjust_shndx(shdr.get_sh_info()); - if (data_shndx >= sec_shnum) + if (data_shndx >= shnum) { // We already warned about this above. continue; @@ -1351,8 +1351,8 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, Relocatable_relocs* rr = new Relocatable_relocs(); this->set_relocatable_relocs(i, rr); - Output_section* os = alayout->layout_reloc(this, i, shdr, data_section, - rr); + Output_section* os = layout->layout_reloc(this, i, shdr, data_section, + rr); out_sections[i] = os; out_section_offsets[i] = invalid_address; } @@ -1371,18 +1371,18 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, pshdr = section_headers_data + i * This::shdr_size; typename This::Shdr shdr(pshdr); - off_t off; - Output_section* os = alayout->layout_eh_frame(this, - symbols_data, - symbols_size, - symbol_names_data, - symbol_names_size, - i, shdr, - reloc_shndx[i], - reloc_type[i], - &off); + off_t offset; + Output_section* os = layout->layout_eh_frame(this, + symbols_data, + symbols_size, + symbol_names_data, + symbol_names_size, + i, shdr, + reloc_shndx[i], + reloc_type[i], + &offset); out_sections[i] = os; - if (off == -1) + if (offset == -1) { // An object can contain at most one section holding exception // frame information. @@ -1391,12 +1391,12 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, out_section_offsets[i] = invalid_address; } else - out_section_offsets[i] = convert_types<Address, off_t>(off); + out_section_offsets[i] = convert_types<Address, off_t>(offset); // If this section requires special handling, and if there are // relocs that apply to it, then we must do the special handling // before we apply the relocs. - if (off == -1 && reloc_shndx[i] != 0) + if (offset == -1 && reloc_shndx[i] != 0) this->set_relocs_must_follow_section_writes(); } @@ -1422,7 +1422,7 @@ Sized_relobj<size, big_endian>::do_layout(Symbol_table* symtab, template<int size, bool big_endian> void -Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* alayout) +Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* layout) { typename std::vector<Deferred_layout>::iterator deferred; @@ -1431,7 +1431,7 @@ Sized_relobj<size, big_endian>::do_layout_deferred_sections(Layout* alayout) ++deferred) { typename This::Shdr shdr(deferred->shdr_data_); - this->layout_section(alayout, deferred->shndx_, deferred->name_.c_str(), + this->layout_section(layout, deferred->shndx_, deferred->name_.c_str(), shdr, deferred->reloc_shndx_, deferred->reloc_type_); } @@ -1452,10 +1452,10 @@ Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, return; } - const int symsize = This::sym_size; + const int sym_size = This::sym_size; size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) - / symsize); - if (symcount * symsize != sd->symbols_size - sd->external_symbols_offset) + / sym_size); + if (symcount * sym_size != sd->symbols_size - sd->external_symbols_offset) { this->error(_("size of symbols is not multiple of symbol size")); return; @@ -1497,16 +1497,16 @@ Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool, } // Read the symbol table section header. - const unsigned int sym_tab_shndx = this->symtab_shndx_; + const unsigned int symtab_shndx = this->symtab_shndx_; typename This::Shdr symtabshdr(this, - this->elf_file_.section_header(sym_tab_shndx)); + this->elf_file_.section_header(symtab_shndx)); gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); // Read the local symbols. - const int symsize = This::sym_size; + const int sym_size = This::sym_size; const unsigned int loccount = this->local_symbol_count_; gold_assert(loccount == symtabshdr.get_sh_info()); - off_t locsize = loccount * symsize; + off_t locsize = loccount * sym_size; const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), locsize, true, true); @@ -1522,13 +1522,13 @@ Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool, // Loop over the local symbols. const Output_sections& out_sections(this->output_sections()); - unsigned int sec_shnum = this->shnum(); + unsigned int shnum = this->shnum(); unsigned int count = 0; unsigned int dyncount = 0; // Skip the first, dummy, symbol. - psyms += symsize; + psyms += sym_size; bool discard_locals = parameters->options().discard_locals(); - for (unsigned int i = 1; i < loccount; ++i, psyms += symsize) + for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) { elfcpp::Sym<size, big_endian> sym(psyms); @@ -1549,7 +1549,7 @@ Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool, // Decide whether this symbol should go into the output file. - if ((shndx < sec_shnum && out_sections[shndx] == NULL) + if ((shndx < shnum && out_sections[shndx] == NULL) || (shndx == this->discarded_eh_frame_shndx_)) { lv.set_no_output_symtab_entry(); @@ -1585,11 +1585,11 @@ Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool, // - the symbol has a name. // // We do not discard a symbol if it needs a dynamic symbol entry. - const char* sname = pnames + sym.get_st_name(); + const char* name = pnames + sym.get_st_name(); if (discard_locals && sym.get_st_type() != elfcpp::STT_FILE && !lv.needs_output_dynsym_entry() - && parameters->target().is_local_label_name(sname)) + && parameters->target().is_local_label_name(name)) { lv.set_no_output_symtab_entry(); continue; @@ -1597,20 +1597,20 @@ Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool, // Discard the local symbol if -retain_symbols_file is specified // and the local symbol is not in that file. - if (!parameters->options().should_retain_symbol(sname)) + if (!parameters->options().should_retain_symbol(name)) { lv.set_no_output_symtab_entry(); continue; } // Add the symbol to the symbol table string pool. - pool->add(sname, true, NULL); + pool->add(name, true, NULL); ++count; // If needed, add the symbol to the dynamic symbol table string pool. if (lv.needs_output_dynsym_entry()) { - dynpool->add(sname, true, NULL); + dynpool->add(name, true, NULL); ++dyncount; } } @@ -1638,7 +1638,7 @@ Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index, const bool relocatable = parameters->options().relocatable(); const Output_sections& out_sections(this->output_sections()); const std::vector<Address>& out_offsets(this->section_offsets_); - unsigned int sec_shnum = this->shnum(); + unsigned int shnum = this->shnum(); for (unsigned int i = 1; i < loccount; ++i) { @@ -1662,7 +1662,7 @@ Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index, } else { - if (shndx >= sec_shnum) + if (shndx >= shnum) { this->error(_("local symbol %u section index %u out of range"), i, shndx); @@ -1854,16 +1854,16 @@ Sized_relobj<size, big_endian>::write_local_symbols( } // Read the symbol table section header. - const unsigned int sym_tab_shndx = this->symtab_shndx_; + const unsigned int symtab_shndx = this->symtab_shndx_; typename This::Shdr symtabshdr(this, - this->elf_file_.section_header(sym_tab_shndx)); + this->elf_file_.section_header(symtab_shndx)); gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); const unsigned int loccount = this->local_symbol_count_; gold_assert(loccount == symtabshdr.get_sh_info()); // Read the local symbols. - const int symsize = This::sym_size; - off_t locsize = loccount * symsize; + const int sym_size = This::sym_size; + off_t locsize = loccount * sym_size; const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), locsize, true, false); @@ -1878,12 +1878,12 @@ Sized_relobj<size, big_endian>::write_local_symbols( // Get views into the output file for the portions of the symbol table // and the dynamic symbol table that we will be writing. - off_t output_size = this->output_local_symbol_count_ * symsize; + off_t output_size = this->output_local_symbol_count_ * sym_size; unsigned char* oview = NULL; if (output_size > 0) oview = of->get_output_view(this->local_symbol_offset_, output_size); - off_t dyn_output_size = this->output_local_dynsym_count_ * symsize; + off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size; unsigned char* dyn_oview = NULL; if (dyn_output_size > 0) dyn_oview = of->get_output_view(this->local_dynsym_offset_, @@ -1895,8 +1895,8 @@ Sized_relobj<size, big_endian>::write_local_symbols( unsigned char* ov = oview; unsigned char* dyn_ov = dyn_oview; - psyms += symsize; - for (unsigned int i = 1; i < loccount; ++i, psyms += symsize) + psyms += sym_size; + for (unsigned int i = 1; i < loccount; ++i, psyms += sym_size) { elfcpp::Sym<size, big_endian> isym(psyms); @@ -1927,15 +1927,15 @@ Sized_relobj<size, big_endian>::write_local_symbols( elfcpp::Sym_write<size, big_endian> osym(ov); gold_assert(isym.get_st_name() < strtab_size); - const char* sname = pnames + isym.get_st_name(); - osym.put_st_name(sympool->get_offset(sname)); + const char* name = pnames + isym.get_st_name(); + osym.put_st_name(sympool->get_offset(name)); osym.put_st_value(this->local_values_[i].value(this, 0)); osym.put_st_size(isym.get_st_size()); osym.put_st_info(isym.get_st_info()); osym.put_st_other(isym.get_st_other()); osym.put_st_shndx(st_shndx); - ov += symsize; + ov += sym_size; } // Write the symbol to the output dynamic symbol table. @@ -1945,15 +1945,15 @@ Sized_relobj<size, big_endian>::write_local_symbols( elfcpp::Sym_write<size, big_endian> osym(dyn_ov); gold_assert(isym.get_st_name() < strtab_size); - const char* sname = pnames + isym.get_st_name(); - osym.put_st_name(dynpool->get_offset(sname)); + const char* name = pnames + isym.get_st_name(); + osym.put_st_name(dynpool->get_offset(name)); osym.put_st_value(this->local_values_[i].value(this, 0)); osym.put_st_size(isym.get_st_size()); osym.put_st_info(isym.get_st_info()); osym.put_st_other(isym.get_st_other()); osym.put_st_shndx(st_shndx); - dyn_ov += symsize; + dyn_ov += sym_size; } } @@ -1980,7 +1980,7 @@ template<int size, bool big_endian> bool Sized_relobj<size, big_endian>::get_symbol_location_info( unsigned int shndx, - off_t sym_offset, + off_t offset, Symbol_location_info* info) { if (this->symtab_shndx_ == 0) @@ -1998,11 +1998,11 @@ Sized_relobj<size, big_endian>::get_symbol_location_info( this->section_contents(symbol_names_shndx, &names_size, false); const char* symbol_names = reinterpret_cast<const char*>(symbol_names_u); - const int symsize = This::sym_size; - const size_t count = symbols_size / symsize; + const int sym_size = This::sym_size; + const size_t count = symbols_size / sym_size; const unsigned char* p = symbols; - for (size_t i = 0; i < count; ++i, p += symsize) + for (size_t i = 0; i < count; ++i, p += sym_size) { elfcpp::Sym<size, big_endian> sym(p); @@ -2020,9 +2020,9 @@ Sized_relobj<size, big_endian>::get_symbol_location_info( &is_ordinary); if (is_ordinary && st_shndx == shndx - && static_cast<off_t>(sym.get_st_value()) <= sym_offset + && static_cast<off_t>(sym.get_st_value()) <= offset && (static_cast<off_t>(sym.get_st_value() + sym.get_st_size()) - > sym_offset)) + > offset)) { if (sym.get_st_name() > names_size) info->enclosing_symbol_name = "(invalid)"; @@ -2065,11 +2065,11 @@ Sized_relobj<size, big_endian>::map_to_kept_section( Sized_relobj<size, big_endian>* kept_relobj = static_cast<Sized_relobj<size, big_endian>*>(kept_object); Output_section* os = kept_relobj->output_section(kept_shndx); - Address addr_offset = kept_relobj->get_output_section_offset(kept_shndx); - if (os != NULL && addr_offset != invalid_address) + Address offset = kept_relobj->get_output_section_offset(kept_shndx); + if (os != NULL && offset != invalid_address) { *found = true; - return os->address() + addr_offset; + return os->address() + offset; } } *found = false; diff --git a/gold/object.h b/gold/object.h index c2359be..187a101 100644 --- a/gold/object.h +++ b/gold/object.h @@ -192,12 +192,12 @@ class Object // (e.g., libfoo.a(bar.o) if this is in an archive. INPUT_FILE is // used to read the file. OFFSET is the offset within the input // file--0 for a .o or .so file, something else for a .a file. - Object(const std::string& oname, Input_file* oinput_file, bool ois_dynamic, - off_t ooffset = 0) - : name_(oname), input_file_(oinput_file), offset_(ooffset), shnum_(-1U), - is_dynamic_(ois_dynamic), is_needed_(false), uses_split_stack_(false), + Object(const std::string& name, Input_file* input_file, bool is_dynamic, + off_t offset = 0) + : name_(name), input_file_(input_file), offset_(offset), shnum_(-1U), + is_dynamic_(is_dynamic), is_needed_(false), uses_split_stack_(false), has_no_split_stack_(false), no_export_(false), xindex_(NULL) - { oinput_file->file().add_object(); } + { input_file->file().add_object(); } virtual ~Object() { this->input_file_->file().remove_object(); } @@ -372,13 +372,13 @@ class Object // Pass sections which should be included in the link to the Layout // object, and record where the sections go in the output file. void - layout(Symbol_table* symtab, Layout* olayout, Read_symbols_data* sd) - { this->do_layout(symtab, olayout, sd); } + layout(Symbol_table* symtab, Layout* layout, Read_symbols_data* sd) + { this->do_layout(symtab, layout, sd); } // Add symbol information to the global symbol table. void - add_symbols(Symbol_table* symtab, Read_symbols_data* sd, Layout *olayout) - { this->do_add_symbols(symtab, sd, olayout); } + add_symbols(Symbol_table* symtab, Read_symbols_data* sd, Layout *layout) + { this->do_add_symbols(symtab, sd, layout); } // Functions and types for the elfcpp::Elf_file interface. This // permit us to use Object as the File template parameter for @@ -555,8 +555,8 @@ class Object // Set the number of sections. void - set_shnum(int sec_shnum) - { this->shnum_ = sec_shnum; } + set_shnum(int shnum) + { this->shnum_ = shnum; } // Functions used by both Sized_relobj and Sized_dynobj. @@ -625,8 +625,8 @@ class Object class Relobj : public Object { public: - Relobj(const std::string& rname, Input_file* rinput_file, off_t roffset = 0) - : Object(rname, rinput_file, false, roffset), + Relobj(const std::string& name, Input_file* input_file, off_t offset = 0) + : Object(name, input_file, false, offset), output_sections_(), map_to_relocatable_relocs_(NULL), object_merge_map_(NULL), @@ -676,13 +676,13 @@ class Relobj : public Object // Process the relocs, during garbage collection only. void - gc_process_relocs(Symbol_table* symtab, Layout* olayout, Read_relocs_data* rd) - { return this->do_gc_process_relocs(symtab, olayout, rd); } + gc_process_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd) + { return this->do_gc_process_relocs(symtab, layout, rd); } // Scan the relocs and adjust the symbol table. void - scan_relocs(Symbol_table* symtab, Layout* olayout, Read_relocs_data* rd) - { return this->do_scan_relocs(symtab, olayout, rd); } + scan_relocs(Symbol_table* symtab, Layout* layout, Read_relocs_data* rd) + { return this->do_scan_relocs(symtab, layout, rd); } // The number of local symbols in the input symbol table. virtual unsigned int @@ -716,8 +716,8 @@ class Relobj : public Object // Relocate the input sections and write out the local symbols. void - relocate(const Symbol_table* symtab, const Layout* olayout, Output_file* of) - { return this->do_relocate(symtab, olayout, of); } + relocate(const Symbol_table* symtab, const Layout* layout, Output_file* of) + { return this->do_relocate(symtab, layout, of); } // Return whether an input section is being included in the link. bool @@ -789,8 +789,8 @@ class Relobj : public Object // Layout sections whose layout was deferred while waiting for // input files from a plugin. void - layout_deferred_sections(Layout* olayout) - { this->do_layout_deferred_sections(olayout); } + layout_deferred_sections(Layout* layout) + { this->do_layout_deferred_sections(layout); } protected: // The output section to be used for each input section, indexed by @@ -1018,8 +1018,8 @@ class Symbol_value // Set the value of this symbol in the output symbol table. void - set_output_value(Value val) - { this->u_.value = val; } + set_output_value(Value value) + { this->u_.value = value; } // For a section symbol in a merged section, we need more // information. @@ -1058,8 +1058,8 @@ class Symbol_value // called by count_local_symbols, to communicate the value to // finalize_local_symbols. void - set_input_value(Value val) - { this->u_.value = val; } + set_input_value(Value value) + { this->u_.value = value; } // Return the input value. This is only called by // finalize_local_symbols and (in special cases) relocate_section. @@ -1735,9 +1735,9 @@ class Sized_relobj : public Relobj // Relocate the sections in the output file. void - relocate_sections(const Symbol_table* symtab, const Layout* olayout, + relocate_sections(const Symbol_table* symtab, const Layout* layout, const unsigned char* pshdrs, Views* pviews) - { this->do_relocate_sections(symtab, olayout, pshdrs, pviews); } + { this->do_relocate_sections(symtab, layout, pshdrs, pviews); } // Scan the input relocations for --emit-relocs. void diff --git a/gold/options.h b/gold/options.h index db10ee6..399c301 100644 --- a/gold/options.h +++ b/gold/options.h @@ -227,9 +227,9 @@ struct Struct_special : public Struct_var parse(parse_function) { } - void parse_to_value(const char* opt, const char* arg, + void parse_to_value(const char* option, const char* arg, Command_line* cmdline, General_options* options) - { (options->*(this->parse))(opt, arg, cmdline); } + { (options->*(this->parse))(option, arg, cmdline); } One_option option; Parse_function parse; @@ -517,8 +517,8 @@ class Search_directory { } // This is the usual constructor. - Search_directory(const char* cname, bool put_in_sysroot) - : name_(cname), put_in_sysroot_(put_in_sysroot), is_in_sysroot_(false) + Search_directory(const char* name, bool put_in_sysroot) + : name_(name), put_in_sysroot_(put_in_sysroot), is_in_sysroot_(false) { if (this->name_.empty()) this->name_ = "."; @@ -1298,24 +1298,24 @@ class Input_file_argument just_symbols_(false), options_() { } - Input_file_argument(const char* aname, Input_file_type type, - const char* aextra_search_path, - bool ajust_symbols, - const Position_dependent_options& aoptions) - : name_(aname), type_(type), extra_search_path_(aextra_search_path), - just_symbols_(ajust_symbols), options_(aoptions) + Input_file_argument(const char* name, Input_file_type type, + const char* extra_search_path, + bool just_symbols, + const Position_dependent_options& options) + : name_(name), type_(type), extra_search_path_(extra_search_path), + just_symbols_(just_symbols), options_(options) { } // You can also pass in a General_options instance instead of a // Position_dependent_options. In that case, we extract the // position-independent vars from the General_options and only store // those. - Input_file_argument(const char* aname, Input_file_type type, - const char* aextra_search_path, - bool ajust_symbols, - const General_options& aoptions) - : name_(aname), type_(type), extra_search_path_(aextra_search_path), - just_symbols_(ajust_symbols), options_(aoptions) + Input_file_argument(const char* name, Input_file_type type, + const char* extra_search_path, + bool just_symbols, + const General_options& options) + : name_(name), type_(type), extra_search_path_(extra_search_path), + just_symbols_(just_symbols), options_(options) { } const char* @@ -1374,13 +1374,13 @@ class Input_argument { public: // Create a file or library argument. - explicit Input_argument(Input_file_argument afile) - : is_file_(true), file_(afile), group_(NULL) + explicit Input_argument(Input_file_argument file) + : is_file_(true), file_(file), group_(NULL) { } // Create a group argument. - explicit Input_argument(Input_file_group* agroup) - : is_file_(false), group_(agroup) + explicit Input_argument(Input_file_group* group) + : is_file_(false), group_(group) { } // Return whether this is a file. diff --git a/gold/output.cc b/gold/output.cc index 2f9ed23..61c2ba6 100644 --- a/gold/output.cc +++ b/gold/output.cc @@ -354,13 +354,13 @@ Output_segment_headers::do_size() const Output_file_header::Output_file_header(const Target* target, const Symbol_table* symtab, const Output_segment_headers* osh, - const char* aentry) + const char* entry) : target_(target), symtab_(symtab), segment_header_(osh), section_header_(NULL), shstrtab_(NULL), - entry_(aentry) + entry_(entry) { this->set_data_size(this->do_size()); } @@ -509,11 +509,11 @@ Output_file_header::entry() && !parameters->options().shared()); // FIXME: Need to support target specific entry symbol. - const char* entry_sym = this->entry_; - if (entry_sym == NULL) - entry_sym = "_start"; + const char* entry = this->entry_; + if (entry == NULL) + entry = "_start"; - Symbol* sym = this->symtab_->lookup(entry_sym); + Symbol* sym = this->symtab_->lookup(entry); typename Sized_symbol<size>::Value_type v; if (sym != NULL) @@ -521,7 +521,7 @@ Output_file_header::entry() Sized_symbol<size>* ssym; ssym = this->symtab_->get_sized_symbol<size>(sym); if (!ssym->is_defined() && should_issue_warning) - gold_warning("entry symbol '%s' exists but is not defined", entry_sym); + gold_warning("entry symbol '%s' exists but is not defined", entry); v = ssym->value(); } else @@ -529,11 +529,11 @@ Output_file_header::entry() // We couldn't find the entry symbol. See if we can parse it as // a number. This supports, e.g., -e 0x1000. char* endptr; - v = strtoull(entry_sym, &endptr, 0); + v = strtoull(entry, &endptr, 0); if (*endptr != '\0') { if (should_issue_warning) - gold_warning("cannot find entry symbol '%s'", entry_sym); + gold_warning("cannot find entry symbol '%s'", entry); v = 0; } } @@ -596,12 +596,12 @@ Output_section_data::do_out_shndx() const // of the output section. void -Output_section_data::set_addralign(uint64_t addr_align) +Output_section_data::set_addralign(uint64_t addralign) { - this->addralign_ = addr_align; + this->addralign_ = addralign; if (this->output_section_ != NULL - && this->output_section_->addralign() < addr_align) - this->output_section_->set_addralign(addr_align); + && this->output_section_->addralign() < addralign) + this->output_section_->set_addralign(addralign); } // Output_data_strtab methods. @@ -633,9 +633,9 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( unsigned int type, Output_data* od, Address address, - bool is_rel) + bool is_relative) : address_(address), local_sym_index_(GSYM_CODE), type_(type), - is_relative_(is_rel), is_section_symbol_(false), shndx_(INVALID_CODE) + is_relative_(is_relative), is_section_symbol_(false), shndx_(INVALID_CODE) { // this->type_ is a bitfield; make sure TYPE fits. gold_assert(this->type_ == type); @@ -652,9 +652,9 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( Sized_relobj<size, big_endian>* relobj, unsigned int shndx, Address address, - bool is_rel) + bool is_relative) : address_(address), local_sym_index_(GSYM_CODE), type_(type), - is_relative_(is_rel), is_section_symbol_(false), shndx_(shndx) + is_relative_(is_relative), is_section_symbol_(false), shndx_(shndx) { gold_assert(shndx != INVALID_CODE); // this->type_ is a bitfield; make sure TYPE fits. @@ -674,10 +674,10 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( unsigned int type, Output_data* od, Address address, - bool is_rel, + bool is_relative, bool is_section_symbol) : address_(address), local_sym_index_(local_sym_index), type_(type), - is_relative_(is_rel), is_section_symbol_(is_section_symbol), + is_relative_(is_relative), is_section_symbol_(is_section_symbol), shndx_(INVALID_CODE) { gold_assert(local_sym_index != GSYM_CODE @@ -697,10 +697,10 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc( unsigned int type, unsigned int shndx, Address address, - bool is_rel, + bool is_relative, bool is_section_symbol) : address_(address), local_sym_index_(local_sym_index), type_(type), - is_relative_(is_rel), is_section_symbol_(is_section_symbol), + is_relative_(is_relative), is_section_symbol_(is_section_symbol), shndx_(shndx) { gold_assert(local_sym_index != GSYM_CODE @@ -1222,9 +1222,9 @@ Output_data_got<size, big_endian>::add_global_with_rel( this->entries_.push_back(Got_entry()); this->set_got_size(); - unsigned int g_offset = this->last_got_offset(); - gsym->set_got_offset(got_type, g_offset); - rel_dyn->add_global(gsym, r_type, this, g_offset); + unsigned int got_offset = this->last_got_offset(); + gsym->set_got_offset(got_type, got_offset); + rel_dyn->add_global(gsym, r_type, this, got_offset); } template<int size, bool big_endian> @@ -1240,9 +1240,9 @@ Output_data_got<size, big_endian>::add_global_with_rela( this->entries_.push_back(Got_entry()); this->set_got_size(); - unsigned int g_offset = this->last_got_offset(); - gsym->set_got_offset(got_type, g_offset); - rela_dyn->add_global(gsym, r_type, this, g_offset, 0); + unsigned int got_offset = this->last_got_offset(); + gsym->set_got_offset(got_type, got_offset); + rela_dyn->add_global(gsym, r_type, this, got_offset, 0); } // Add a pair of entries for a global symbol to the GOT, and add @@ -1261,15 +1261,15 @@ Output_data_got<size, big_endian>::add_global_pair_with_rel( return; this->entries_.push_back(Got_entry()); - unsigned int g_offset = this->last_got_offset(); - gsym->set_got_offset(got_type, g_offset); - rel_dyn->add_global(gsym, r_type_1, this, g_offset); + unsigned int got_offset = this->last_got_offset(); + gsym->set_got_offset(got_type, got_offset); + rel_dyn->add_global(gsym, r_type_1, this, got_offset); this->entries_.push_back(Got_entry()); if (r_type_2 != 0) { - g_offset = this->last_got_offset(); - rel_dyn->add_global(gsym, r_type_2, this, g_offset); + got_offset = this->last_got_offset(); + rel_dyn->add_global(gsym, r_type_2, this, got_offset); } this->set_got_size(); @@ -1288,15 +1288,15 @@ Output_data_got<size, big_endian>::add_global_pair_with_rela( return; this->entries_.push_back(Got_entry()); - unsigned int g_offset = this->last_got_offset(); - gsym->set_got_offset(got_type, g_offset); - rela_dyn->add_global(gsym, r_type_1, this, g_offset, 0); + unsigned int got_offset = this->last_got_offset(); + gsym->set_got_offset(got_type, got_offset); + rela_dyn->add_global(gsym, r_type_1, this, got_offset, 0); this->entries_.push_back(Got_entry()); if (r_type_2 != 0) { - g_offset = this->last_got_offset(); - rela_dyn->add_global(gsym, r_type_2, this, g_offset, 0); + got_offset = this->last_got_offset(); + rela_dyn->add_global(gsym, r_type_2, this, got_offset, 0); } this->set_got_size(); @@ -1338,9 +1338,9 @@ Output_data_got<size, big_endian>::add_local_with_rel( this->entries_.push_back(Got_entry()); this->set_got_size(); - unsigned int g_offset = this->last_got_offset(); - object->set_local_got_offset(symndx, got_type, g_offset); - rel_dyn->add_local(object, symndx, r_type, this, g_offset); + unsigned int got_offset = this->last_got_offset(); + object->set_local_got_offset(symndx, got_type, got_offset); + rel_dyn->add_local(object, symndx, r_type, this, got_offset); } template<int size, bool big_endian> @@ -1357,9 +1357,9 @@ Output_data_got<size, big_endian>::add_local_with_rela( this->entries_.push_back(Got_entry()); this->set_got_size(); - unsigned int g_offset = this->last_got_offset(); - object->set_local_got_offset(symndx, got_type, g_offset); - rela_dyn->add_local(object, symndx, r_type, this, g_offset, 0); + unsigned int got_offset = this->last_got_offset(); + object->set_local_got_offset(symndx, got_type, got_offset); + rela_dyn->add_local(object, symndx, r_type, this, got_offset, 0); } // Add a pair of entries for a local symbol to the GOT, and add @@ -1380,16 +1380,16 @@ Output_data_got<size, big_endian>::add_local_pair_with_rel( return; this->entries_.push_back(Got_entry()); - unsigned int g_offset = this->last_got_offset(); - object->set_local_got_offset(symndx, got_type, g_offset); + unsigned int got_offset = this->last_got_offset(); + object->set_local_got_offset(symndx, got_type, got_offset); Output_section* os = object->output_section(shndx); - rel_dyn->add_output_section(os, r_type_1, this, g_offset); + rel_dyn->add_output_section(os, r_type_1, this, got_offset); this->entries_.push_back(Got_entry(object, symndx)); if (r_type_2 != 0) { - g_offset = this->last_got_offset(); - rel_dyn->add_output_section(os, r_type_2, this, g_offset); + got_offset = this->last_got_offset(); + rel_dyn->add_output_section(os, r_type_2, this, got_offset); } this->set_got_size(); @@ -1410,16 +1410,16 @@ Output_data_got<size, big_endian>::add_local_pair_with_rela( return; this->entries_.push_back(Got_entry()); - unsigned int g_offset = this->last_got_offset(); - object->set_local_got_offset(symndx, got_type, g_offset); + unsigned int got_offset = this->last_got_offset(); + object->set_local_got_offset(symndx, got_type, got_offset); Output_section* os = object->output_section(shndx); - rela_dyn->add_output_section(os, r_type_1, this, g_offset, 0); + rela_dyn->add_output_section(os, r_type_1, this, got_offset, 0); this->entries_.push_back(Got_entry(object, symndx)); if (r_type_2 != 0) { - g_offset = this->last_got_offset(); - rela_dyn->add_output_section(os, r_type_2, this, g_offset, 0); + got_offset = this->last_got_offset(); + rela_dyn->add_output_section(os, r_type_2, this, got_offset, 0); } this->set_got_size(); @@ -1571,9 +1571,9 @@ Output_data_dynamic::sized_write(Output_file* of) { const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size; - const off_t off = this->offset(); + const off_t offset = this->offset(); const off_t oview_size = this->data_size(); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); unsigned char* pov = oview; for (typename Dynamic_entries::const_iterator p = this->entries_.begin(); @@ -1586,7 +1586,7 @@ Output_data_dynamic::sized_write(Output_file* of) gold_assert(pov - oview == oview_size); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); // We no longer need the dynamic entries. this->entries_.clear(); @@ -1597,9 +1597,9 @@ Output_data_dynamic::sized_write(Output_file* of) void Output_symtab_xindex::do_write(Output_file* of) { - const off_t off = this->offset(); + const off_t offset = this->offset(); const off_t oview_size = this->data_size(); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); memset(oview, 0, oview_size); @@ -1608,7 +1608,7 @@ Output_symtab_xindex::do_write(Output_file* of) else this->endian_do_write<false>(oview); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); // We no longer need the data. this->entries_.clear(); @@ -1682,17 +1682,17 @@ Output_section::Input_section::finalize_data_size() inline bool Output_section::Input_section::output_offset( const Relobj* object, - unsigned int sec_shndx, - section_offset_type off, + unsigned int shndx, + section_offset_type offset, section_offset_type *poutput) const { if (!this->is_input_section()) - return this->u2_.posd->output_offset(object, sec_shndx, off, poutput); + return this->u2_.posd->output_offset(object, shndx, offset, poutput); else { - if (this->shndx_ != sec_shndx || this->u2_.object != object) + if (this->shndx_ != shndx || this->u2_.object != object) return false; - *poutput = off; + *poutput = offset; return true; } } @@ -1702,11 +1702,11 @@ Output_section::Input_section::output_offset( inline bool Output_section::Input_section::is_merge_section_for(const Relobj* object, - unsigned int sec_shndx) const + unsigned int shndx) const { if (this->is_input_section()) return false; - return this->u2_.posd->is_merge_section_for(object, sec_shndx); + return this->u2_.posd->is_merge_section_for(object, shndx); } // Write out the data. We don't have to do anything for an input @@ -1761,9 +1761,9 @@ Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const // Construct an Output_section. NAME will point into a Stringpool. -Output_section::Output_section(const char* aname, elfcpp::Elf_Word atype, - elfcpp::Elf_Xword aflags) - : name_(aname), +Output_section::Output_section(const char* name, elfcpp::Elf_Word type, + elfcpp::Elf_Xword flags) + : name_(name), addralign_(0), entsize_(0), load_address_(0), @@ -1772,8 +1772,8 @@ Output_section::Output_section(const char* aname, elfcpp::Elf_Word atype, info_section_(NULL), info_symndx_(NULL), info_(0), - type_(atype), - flags_(aflags), + type_(type), + flags_(flags), out_shndx_(-1U), symtab_index_(0), dynsym_index_(0), @@ -1810,7 +1810,7 @@ Output_section::Output_section(const char* aname, elfcpp::Elf_Word atype, // An unallocated section has no address. Forcing this means that // we don't need special treatment for symbols defined in debug // sections. - if ((aflags & elfcpp::SHF_ALLOC) == 0) + if ((flags & elfcpp::SHF_ALLOC) == 0) this->set_address(0); } @@ -1845,34 +1845,34 @@ Output_section::set_entsize(uint64_t v) template<int size, bool big_endian> off_t Output_section::add_input_section(Sized_relobj<size, big_endian>* object, - unsigned int sec_shndx, + unsigned int shndx, const char* secname, const elfcpp::Shdr<size, big_endian>& shdr, unsigned int reloc_shndx, bool have_sections_script) { - elfcpp::Elf_Xword addr_align = shdr.get_sh_addralign(); - if ((addr_align & (addr_align - 1)) != 0) + elfcpp::Elf_Xword addralign = shdr.get_sh_addralign(); + if ((addralign & (addralign - 1)) != 0) { object->error(_("invalid alignment %lu for section \"%s\""), - static_cast<unsigned long>(addr_align), secname); - addr_align = 1; + static_cast<unsigned long>(addralign), secname); + addralign = 1; } - if (addr_align > this->addralign_) - this->addralign_ = addr_align; + if (addralign > this->addralign_) + this->addralign_ = addralign; typename elfcpp::Elf_types<size>::Elf_WXword sh_flags = shdr.get_sh_flags(); this->update_flags_for_input_section(sh_flags); - uint64_t ent_size = shdr.get_sh_entsize(); + uint64_t entsize = shdr.get_sh_entsize(); // .debug_str is a mergeable string section, but is not always so // marked by compilers. Mark manually here so we can optimize. if (strcmp(secname, ".debug_str") == 0) { sh_flags |= (elfcpp::SHF_MERGE | elfcpp::SHF_STRINGS); - ent_size = 1; + entsize = 1; } // If this is a SHF_MERGE section, we pass all the input sections to @@ -1883,8 +1883,8 @@ Output_section::add_input_section(Sized_relobj<size, big_endian>* object, && reloc_shndx == 0 && shdr.get_sh_size() > 0) { - if (this->add_merge_input_section(object, sec_shndx, sh_flags, - ent_size, addr_align)) + if (this->add_merge_input_section(object, shndx, sh_flags, + entsize, addralign)) { // Tell the relocation routines that they need to call the // output_offset method to determine the final address. @@ -1894,7 +1894,7 @@ Output_section::add_input_section(Sized_relobj<size, big_endian>* object, off_t offset_in_section = this->current_data_size_for_child(); off_t aligned_offset_in_section = align_address(offset_in_section, - addr_align); + addralign); // Determine if we want to delay code-fill generation until the output // section is written. When the target is relaxing, we want to delay fill @@ -1942,9 +1942,9 @@ Output_section::add_input_section(Sized_relobj<size, big_endian>* object, || this->must_sort_attached_input_sections() || parameters->options().user_set_Map() || parameters->target().may_relax()) - this->input_sections_.push_back(Input_section(object, sec_shndx, + this->input_sections_.push_back(Input_section(object, shndx, shdr.get_sh_size(), - addr_align)); + addralign)); return aligned_offset_in_section; } @@ -2002,9 +2002,9 @@ Output_section::add_output_section_data(Input_section* inp) this->input_sections_.push_back(*inp); - uint64_t addr_align = inp->addralign(); - if (addr_align > this->addralign_) - this->addralign_ = addr_align; + uint64_t addralign = inp->addralign(); + if (addralign > this->addralign_) + this->addralign_ = addralign; inp->set_output_section(this); } @@ -2013,43 +2013,43 @@ Output_section::add_output_section_data(Input_section* inp) void Output_section::add_output_merge_section(Output_section_data* posd, - bool is_string, uint64_t ent_size) + bool is_string, uint64_t entsize) { - Input_section inp(posd, is_string, ent_size); + Input_section inp(posd, is_string, entsize); this->add_output_section_data(&inp); } // Add an input section to a SHF_MERGE section. bool -Output_section::add_merge_input_section(Relobj* object, unsigned int sec_shndx, - uint64_t aflags, uint64_t ent_size, - uint64_t addr_align) +Output_section::add_merge_input_section(Relobj* object, unsigned int shndx, + uint64_t flags, uint64_t entsize, + uint64_t addralign) { - bool is_string = (aflags & elfcpp::SHF_STRINGS) != 0; + bool is_string = (flags & elfcpp::SHF_STRINGS) != 0; // We only merge strings if the alignment is not more than the // character size. This could be handled, but it's unusual. - if (is_string && addr_align > ent_size) + if (is_string && addralign > entsize) return false; // We cannot restore merged input section states. gold_assert(this->checkpoint_ == NULL); // Look up merge sections by required properties. - Merge_section_properties msp(is_string, ent_size, addr_align); + Merge_section_properties msp(is_string, entsize, addralign); Merge_section_by_properties_map::const_iterator p = this->merge_section_by_properties_map_.find(msp); if (p != this->merge_section_by_properties_map_.end()) { Output_merge_base* merge_section = p->second; - merge_section->add_input_section(object, sec_shndx); + merge_section->add_input_section(object, shndx); gold_assert(merge_section->is_string() == is_string - && merge_section->entsize() == ent_size - && merge_section->addralign() == addr_align); + && merge_section->entsize() == entsize + && merge_section->addralign() == addralign); // Link input section to found merge section. - Input_section_specifier iss(object, sec_shndx); + Input_section_specifier iss(object, shndx); this->merge_section_map_[iss] = merge_section; return true; } @@ -2058,19 +2058,19 @@ Output_section::add_merge_input_section(Relobj* object, unsigned int sec_shndx, // Output_merge_string_data. Output_merge_base* pomb; if (!is_string) - pomb = new Output_merge_data(ent_size, addr_align); + pomb = new Output_merge_data(entsize, addralign); else { - switch (ent_size) + switch (entsize) { case 1: - pomb = new Output_merge_string<char>(addr_align); + pomb = new Output_merge_string<char>(addralign); break; case 2: - pomb = new Output_merge_string<uint16_t>(addr_align); + pomb = new Output_merge_string<uint16_t>(addralign); break; case 4: - pomb = new Output_merge_string<uint32_t>(addr_align); + pomb = new Output_merge_string<uint32_t>(addralign); break; default: return false; @@ -2079,30 +2079,30 @@ Output_section::add_merge_input_section(Relobj* object, unsigned int sec_shndx, // Add new merge section to this output section and link merge section // properties to new merge section in map. - this->add_output_merge_section(pomb, is_string, ent_size); + this->add_output_merge_section(pomb, is_string, entsize); this->merge_section_by_properties_map_[msp] = pomb; // Add input section to new merge section and link input section to new // merge section in map. - pomb->add_input_section(object, sec_shndx); - Input_section_specifier iss(object, sec_shndx); + pomb->add_input_section(object, shndx); + Input_section_specifier iss(object, shndx); this->merge_section_map_[iss] = pomb; return true; } // Build a relaxation map to speed up relaxation of existing input sections. -// Look up to the first LIMIT elements in INPUTSECTIONS. +// Look up to the first LIMIT elements in INPUT_SECTIONS. void Output_section::build_relaxation_map( - const Input_section_list& inputsections, + const Input_section_list& input_sections, size_t limit, Relaxation_map* relaxation_map) const { for (size_t i = 0; i < limit; ++i) { - const Input_section& is(inputsections[i]); + const Input_section& is(input_sections[i]); if (is.is_input_section() || is.is_relaxed_input_section()) { Input_section_specifier iss(is.relobj(), is.shndx()); @@ -2113,13 +2113,13 @@ Output_section::build_relaxation_map( // Convert regular input sections in INPUT_SECTIONS into relaxed input // sections in RELAXED_SECTIONS. MAP is a prebuilt map from input section -// specifier to indices of INPUTSECTIONS. +// specifier to indices of INPUT_SECTIONS. void Output_section::convert_input_sections_in_list_to_relaxed_sections( const std::vector<Output_relaxed_input_section*>& relaxed_sections, const Relaxation_map& map, - Input_section_list* inputsections) + Input_section_list* input_sections) { for (size_t i = 0; i < relaxed_sections.size(); ++i) { @@ -2127,8 +2127,8 @@ Output_section::convert_input_sections_in_list_to_relaxed_sections( Input_section_specifier iss(poris->relobj(), poris->shndx()); Relaxation_map::const_iterator p = map.find(iss); gold_assert(p != map.end()); - gold_assert((*inputsections)[p->second].is_input_section()); - (*inputsections)[p->second] = Input_section(poris); + gold_assert((*input_sections)[p->second].is_input_section()); + (*input_sections)[p->second] = Input_section(poris); } } @@ -2186,35 +2186,35 @@ Output_section::convert_input_sections_to_relaxed_sections( // Update the output section flags based on input section flags. void -Output_section::update_flags_for_input_section(elfcpp::Elf_Xword aflags) +Output_section::update_flags_for_input_section(elfcpp::Elf_Xword flags) { // If we created the section with SHF_ALLOC clear, we set the // address. If we are now setting the SHF_ALLOC flag, we need to // undo that. if ((this->flags_ & elfcpp::SHF_ALLOC) == 0 - && (aflags & elfcpp::SHF_ALLOC) != 0) + && (flags & elfcpp::SHF_ALLOC) != 0) this->mark_address_invalid(); - this->flags_ |= (aflags + this->flags_ |= (flags & (elfcpp::SHF_WRITE | elfcpp::SHF_ALLOC | elfcpp::SHF_EXECINSTR)); } -// Find the merge section into which an input section with index SEC_SHNDX in +// Find the merge section into which an input section with index SHNDX in // OBJECT has been added. Return NULL if none found. Output_section_data* Output_section::find_merge_section(const Relobj* object, - unsigned int sec_shndx) const + unsigned int shndx) const { - Input_section_specifier iss(object, sec_shndx); + Input_section_specifier iss(object, shndx); Output_section_data_by_input_section_map::const_iterator p = this->merge_section_map_.find(iss); if (p != this->merge_section_map_.end()) { Output_section_data* posd = p->second; - gold_assert(posd->is_merge_section_for(object, sec_shndx)); + gold_assert(posd->is_merge_section_for(object, shndx)); return posd; } else @@ -2222,11 +2222,11 @@ Output_section::find_merge_section(const Relobj* object, } // Find an relaxed input section corresponding to an input section -// in OBJECT with index SEC_SHNDX. +// in OBJECT with index SHNDX. const Output_section_data* Output_section::find_relaxed_input_section(const Relobj* object, - unsigned int sec_shndx) const + unsigned int shndx) const { // Be careful that the map may not be valid due to input section export // to scripts or a check-point restore. @@ -2246,7 +2246,7 @@ Output_section::find_relaxed_input_section(const Relobj* object, this->is_relaxed_input_section_map_valid_ = true; } - Input_section_specifier iss(object, sec_shndx); + Input_section_specifier iss(object, shndx); Output_section_data_by_input_section_map::const_iterator p = this->relaxed_input_section_map_.find(iss); if (p != this->relaxed_input_section_map_.end()) @@ -2255,27 +2255,27 @@ Output_section::find_relaxed_input_section(const Relobj* object, return NULL; } -// Given an address OFF relative to the start of input section -// SEC_SHNDX in OBJECT, return whether this address is being included in -// the final link. This should only be called if SEC_SHNDX in OBJECT has +// Given an address OFFSET relative to the start of input section +// SHNDX in OBJECT, return whether this address is being included in +// the final link. This should only be called if SHNDX in OBJECT has // a special mapping. bool Output_section::is_input_address_mapped(const Relobj* object, - unsigned int sec_shndx, - off_t off) const + unsigned int shndx, + off_t offset) const { // Look at the Output_section_data_maps first. - const Output_section_data* posd = this->find_merge_section(object, sec_shndx); + const Output_section_data* posd = this->find_merge_section(object, shndx); if (posd == NULL) - posd = this->find_relaxed_input_section(object, sec_shndx); + posd = this->find_relaxed_input_section(object, shndx); if (posd != NULL) { - section_offset_type outputoffset; - bool found = posd->output_offset(object, sec_shndx, off, &outputoffset); + section_offset_type output_offset; + bool found = posd->output_offset(object, shndx, offset, &output_offset); gold_assert(found); - return outputoffset != -1; + return output_offset != -1; } // Fall back to the slow look-up. @@ -2283,9 +2283,9 @@ Output_section::is_input_address_mapped(const Relobj* object, p != this->input_sections_.end(); ++p) { - section_offset_type outputoffset; - if (p->output_offset(object, sec_shndx, off, &outputoffset)) - return outputoffset != -1; + section_offset_type output_offset; + if (p->output_offset(object, shndx, offset, &output_offset)) + return output_offset != -1; } // By default we assume that the address is mapped. This should @@ -2294,29 +2294,29 @@ Output_section::is_input_address_mapped(const Relobj* object, return true; } -// Given an address OFF relative to the start of input section -// SEC_SHNDX in object OBJECT, return the output offset relative to the +// Given an address OFFSET relative to the start of input section +// SHNDX in object OBJECT, return the output offset relative to the // start of the input section in the output section. This should only -// be called if SEC_SHNDX in OBJECT has a special mapping. +// be called if SHNDX in OBJECT has a special mapping. section_offset_type -Output_section::output_offset(const Relobj* object, unsigned int sec_shndx, - section_offset_type off) const +Output_section::output_offset(const Relobj* object, unsigned int shndx, + section_offset_type offset) const { // This can only be called meaningfully when we know the data size // of this. gold_assert(this->is_data_size_valid()); // Look at the Output_section_data_maps first. - const Output_section_data* posd = this->find_merge_section(object, sec_shndx); + const Output_section_data* posd = this->find_merge_section(object, shndx); if (posd == NULL) - posd = this->find_relaxed_input_section(object, sec_shndx); + posd = this->find_relaxed_input_section(object, shndx); if (posd != NULL) { - section_offset_type outputoffset; - bool found = posd->output_offset(object, sec_shndx, off, &outputoffset); + section_offset_type output_offset; + bool found = posd->output_offset(object, shndx, offset, &output_offset); gold_assert(found); - return outputoffset; + return output_offset; } // Fall back to the slow look-up. @@ -2324,32 +2324,32 @@ Output_section::output_offset(const Relobj* object, unsigned int sec_shndx, p != this->input_sections_.end(); ++p) { - section_offset_type outputoffset; - if (p->output_offset(object, sec_shndx, off, &outputoffset)) - return outputoffset; + section_offset_type output_offset; + if (p->output_offset(object, shndx, offset, &output_offset)) + return output_offset; } gold_unreachable(); } -// Return the output virtual address of OFF relative to the start -// of input section SEC_SHNDX in object OBJECT. +// Return the output virtual address of OFFSET relative to the start +// of input section SHNDX in object OBJECT. uint64_t -Output_section::output_address(const Relobj* object, unsigned int sec_shndx, - off_t off) const +Output_section::output_address(const Relobj* object, unsigned int shndx, + off_t offset) const { uint64_t addr = this->address() + this->first_input_offset_; // Look at the Output_section_data_maps first. - const Output_section_data* posd = this->find_merge_section(object, sec_shndx); + const Output_section_data* posd = this->find_merge_section(object, shndx); if (posd == NULL) - posd = this->find_relaxed_input_section(object, sec_shndx); + posd = this->find_relaxed_input_section(object, shndx); if (posd != NULL && posd->is_address_valid()) { - section_offset_type outputoffset; - bool found = posd->output_offset(object, sec_shndx, off, &outputoffset); + section_offset_type output_offset; + bool found = posd->output_offset(object, shndx, offset, &output_offset); gold_assert(found); - return posd->address() + outputoffset; + return posd->address() + output_offset; } // Fall back to the slow look-up. @@ -2358,12 +2358,12 @@ Output_section::output_address(const Relobj* object, unsigned int sec_shndx, ++p) { addr = align_address(addr, p->addralign()); - section_offset_type outputoffset; - if (p->output_offset(object, sec_shndx, off, &outputoffset)) + section_offset_type output_offset; + if (p->output_offset(object, shndx, offset, &output_offset)) { - if (outputoffset == -1) + if (output_offset == -1) return -1ULL; - return addr + outputoffset; + return addr + output_offset; } addr += p->data_size(); } @@ -2377,11 +2377,11 @@ Output_section::output_address(const Relobj* object, unsigned int sec_shndx, } // Find the output address of the start of the merged section for -// input section SEC_SHNDX in object OBJECT. +// input section SHNDX in object OBJECT. bool Output_section::find_starting_output_address(const Relobj* object, - unsigned int sec_shndx, + unsigned int shndx, uint64_t* paddr) const { // FIXME: This becomes a bottle-neck if we have many relaxed sections. @@ -2398,7 +2398,7 @@ Output_section::find_starting_output_address(const Relobj* object, // method to get the output offset of input offset 0. // Unfortunately we don't know for sure that input offset 0 is // mapped at all. - if (p->is_merge_section_for(object, sec_shndx)) + if (p->is_merge_section_for(object, shndx)) { *paddr = addr; return true; @@ -2426,7 +2426,7 @@ Output_section::set_final_data_size() if (this->must_sort_attached_input_sections()) this->sort_attached_input_sections(); - uint64_t addr = this->address(); + uint64_t address = this->address(); off_t startoff = this->offset(); off_t off = startoff + this->first_input_offset_; for (Input_section_list::iterator p = this->input_sections_.begin(); @@ -2434,7 +2434,7 @@ Output_section::set_final_data_size() ++p) { off = align_address(off, p->addralign()); - p->set_address_and_file_offset(addr + (off - startoff), off, + p->set_address_and_file_offset(address + (off - startoff), off, startoff); off += p->data_size(); } @@ -2498,11 +2498,11 @@ class Output_section::Input_section_sort_entry section_name_() { } - Input_section_sort_entry(const Input_section& inputsection, - unsigned int indx) - : input_section_(inputsection), index_(indx), - section_has_name_(inputsection.is_input_section() - || inputsection.is_relaxed_input_section()) + Input_section_sort_entry(const Input_section& input_section, + unsigned int index) + : input_section_(input_section), index_(index), + section_has_name_(input_section.is_input_section() + || input_section.is_relaxed_input_section()) { if (this->section_has_name_) { @@ -2510,14 +2510,14 @@ class Output_section::Input_section_sort_entry // so it is OK to lock. Unfortunately we have no way to pass // in a Task token. const Task* dummy_task = reinterpret_cast<const Task*>(-1); - Object* obj = (inputsection.is_input_section() - ? inputsection.relobj() - : inputsection.relaxed_input_section()->relobj()); + Object* obj = (input_section.is_input_section() + ? input_section.relobj() + : input_section.relaxed_input_section()->relobj()); Task_lock_obj<Object> tl(dummy_task, obj); // This is a slow operation, which should be cached in // Layout::layout if this becomes a speed problem. - this->section_name_ = obj->section_name(inputsection.shndx()); + this->section_name_ = obj->section_name(input_section.shndx()); } } @@ -2568,12 +2568,12 @@ class Output_section::Input_section_sort_entry // file name this way is a dreadful hack, but the GNU linker does it // in order to better support gcc, and we need to be compatible. bool - match_file_name(const char* match_filename) const + match_file_name(const char* match_file_name) const { const std::string& file_name(this->input_section_.relobj()->name()); const char* base_name = lbasename(file_name.c_str()); - size_t match_len = strlen(match_filename); - if (strncmp(base_name, match_filename, match_len) != 0) + size_t match_len = strlen(match_file_name); + if (strncmp(base_name, match_file_name, match_len) != 0) return false; size_t base_len = strlen(base_name); if (base_len != match_len + 2 && base_len != match_len + 3) @@ -2706,10 +2706,10 @@ Output_section::write_header(const Layout* layout, oshdr->put_sh_name(secnamepool->get_offset(this->name_)); oshdr->put_sh_type(this->type_); - elfcpp::Elf_Xword xflags = this->flags_; + elfcpp::Elf_Xword flags = this->flags_; if (this->info_section_ != NULL && this->info_uses_section_index_) - xflags |= elfcpp::SHF_INFO_LINK; - oshdr->put_sh_flags(xflags); + flags |= elfcpp::SHF_INFO_LINK; + oshdr->put_sh_flags(flags); oshdr->put_sh_addr(this->address()); oshdr->put_sh_offset(this->offset()); @@ -2723,19 +2723,19 @@ Output_section::write_header(const Layout* layout, else oshdr->put_sh_link(this->link_); - elfcpp::Elf_Word inf; + elfcpp::Elf_Word info; if (this->info_section_ != NULL) { if (this->info_uses_section_index_) - inf = this->info_section_->out_shndx(); + info = this->info_section_->out_shndx(); else - inf = this->info_section_->symtab_index(); + info = this->info_section_->symtab_index(); } else if (this->info_symndx_ != NULL) - inf = this->info_symndx_->symtab_index(); + info = this->info_symndx_->symtab_index(); else - inf = this->info_; - oshdr->put_sh_info(inf); + info = this->info_; + oshdr->put_sh_info(info); oshdr->put_sh_addralign(this->addralign_); oshdr->put_sh_entsize(this->entsize_); @@ -2862,9 +2862,9 @@ Output_section::write_to_postprocessing_buffer() uint64_t Output_section::get_input_sections( - uint64_t addr, + uint64_t address, const std::string& fill, - std::list<Simple_input_section>* inputsections) + std::list<Simple_input_section>* input_sections) { if (this->checkpoint_ != NULL && !this->checkpoint_->input_sections_saved()) @@ -2873,9 +2873,9 @@ Output_section::get_input_sections( // Invalidate the relaxed input section map. this->is_relaxed_input_section_map_valid_ = false; - uint64_t orig_address = addr; + uint64_t orig_address = address; - addr = align_address(addr, this->addralign()); + address = align_address(address, this->addralign()); Input_section_list remaining; for (Input_section_list::iterator p = this->input_sections_.begin(); @@ -2883,18 +2883,18 @@ Output_section::get_input_sections( ++p) { if (p->is_input_section()) - inputsections->push_back(Simple_input_section(p->relobj(), + input_sections->push_back(Simple_input_section(p->relobj(), p->shndx())); else if (p->is_relaxed_input_section()) - inputsections->push_back( + input_sections->push_back( Simple_input_section(p->relaxed_input_section())); else { - uint64_t aligned_address = align_address(addr, p->addralign()); - if (aligned_address != addr && !fill.empty()) + uint64_t aligned_address = align_address(address, p->addralign()); + if (aligned_address != address && !fill.empty()) { section_size_type length = - convert_to_section_size_type(aligned_address - addr); + convert_to_section_size_type(aligned_address - address); std::string this_fill; this_fill.reserve(length); while (this_fill.length() + fill.length() <= length) @@ -2905,44 +2905,44 @@ Output_section::get_input_sections( Output_section_data* posd = new Output_data_const(this_fill, 0); remaining.push_back(Input_section(posd)); } - addr = aligned_address; + address = aligned_address; remaining.push_back(*p); p->finalize_data_size(); - addr += p->data_size(); + address += p->data_size(); } } this->input_sections_.swap(remaining); this->first_input_offset_ = 0; - uint64_t datasize = addr - orig_address; - this->set_current_data_size_for_child(datasize); - return datasize; + uint64_t data_size = address - orig_address; + this->set_current_data_size_for_child(data_size); + return data_size; } // Add an input section from a script. void Output_section::add_input_section_for_script(const Simple_input_section& sis, - off_t datasize, - uint64_t addr_align) + off_t data_size, + uint64_t addralign) { - if (addr_align > this->addralign_) - this->addralign_ = addr_align; + if (addralign > this->addralign_) + this->addralign_ = addralign; off_t offset_in_section = this->current_data_size_for_child(); off_t aligned_offset_in_section = align_address(offset_in_section, - addr_align); + addralign); this->set_current_data_size_for_child(aligned_offset_in_section - + datasize); + + data_size); Input_section is = (sis.is_relaxed_input_section() ? Input_section(sis.relaxed_input_section()) - : Input_section(sis.relobj(), sis.shndx(), datasize, addr_align)); + : Input_section(sis.relobj(), sis.shndx(), data_size, addralign)); this->input_sections_.push_back(is); } @@ -3022,7 +3022,7 @@ Output_section::print_merge_stats() // Output segment methods. -Output_segment::Output_segment(elfcpp::Elf_Word atype, elfcpp::Elf_Word aflags) +Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags) : output_data_(), output_bss_(), vaddr_(0), @@ -3032,8 +3032,8 @@ Output_segment::Output_segment(elfcpp::Elf_Word atype, elfcpp::Elf_Word aflags) min_p_align_(0), offset_(0), filesz_(0), - type_(atype), - flags_(aflags), + type_(type), + flags_(flags), is_max_align_known_(false), are_addresses_set_(false), is_large_data_segment_(false) @@ -3332,15 +3332,15 @@ Output_segment::maximum_alignment() { if (!this->is_max_align_known_) { - uint64_t addr_align; + uint64_t addralign; - addr_align = Output_segment::maximum_alignment_list(&this->output_data_); - if (addr_align > this->max_align_) - this->max_align_ = addr_align; + addralign = Output_segment::maximum_alignment_list(&this->output_data_); + if (addralign > this->max_align_) + this->max_align_ = addralign; - addr_align = Output_segment::maximum_alignment_list(&this->output_bss_); - if (addr_align > this->max_align_) - this->max_align_ = addr_align; + addralign = Output_segment::maximum_alignment_list(&this->output_bss_); + if (addralign > this->max_align_) + this->max_align_ = addralign; // If -z relro is in effect, and the first section in this // segment is a relro section, then the segment must be aligned @@ -3350,9 +3350,9 @@ Output_segment::maximum_alignment() && parameters->options().relro() && this->is_first_section_relro()) { - addr_align = parameters->target().common_pagesize(); - if (addr_align > this->max_align_) - this->max_align_ = addr_align; + addralign = parameters->target().common_pagesize(); + if (addralign > this->max_align_) + this->max_align_ = addralign; } this->is_max_align_known_ = true; @@ -3371,9 +3371,9 @@ Output_segment::maximum_alignment_list(const Output_data_list* pdl) p != pdl->end(); ++p) { - uint64_t addr_align = (*p)->addralign(); - if (addr_align > ret) - ret = addr_align; + uint64_t addralign = (*p)->addralign(); + if (addralign > ret) + ret = addralign; } return ret; } @@ -4138,7 +4138,7 @@ template off_t Output_section::add_input_section<32, false>( Sized_relobj<32, false>* object, - unsigned int sec_shndx, + unsigned int shndx, const char* secname, const elfcpp::Shdr<32, false>& shdr, unsigned int reloc_shndx, @@ -4150,7 +4150,7 @@ template off_t Output_section::add_input_section<32, true>( Sized_relobj<32, true>* object, - unsigned int sec_shndx, + unsigned int shndx, const char* secname, const elfcpp::Shdr<32, true>& shdr, unsigned int reloc_shndx, @@ -4162,7 +4162,7 @@ template off_t Output_section::add_input_section<64, false>( Sized_relobj<64, false>* object, - unsigned int sec_shndx, + unsigned int shndx, const char* secname, const elfcpp::Shdr<64, false>& shdr, unsigned int reloc_shndx, @@ -4174,7 +4174,7 @@ template off_t Output_section::add_input_section<64, true>( Sized_relobj<64, true>* object, - unsigned int sec_shndx, + unsigned int shndx, const char* secname, const elfcpp::Shdr<64, true>& shdr, unsigned int reloc_shndx, diff --git a/gold/output.h b/gold/output.h index 21d80fb..6631aa1 100644 --- a/gold/output.h +++ b/gold/output.h @@ -53,8 +53,8 @@ class Sized_relobj; class Input_section_specifier { public: - Input_section_specifier(const Relobj* robj, unsigned int sec_shndx) - : relobj_(robj), shndx_(sec_shndx) + Input_section_specifier(const Relobj* relobj, unsigned int shndx) + : relobj_(relobj), shndx_(shndx) { } // Return Relobj of this. @@ -416,11 +416,11 @@ class Output_data // Set the size of the data. void - set_data_size(off_t datasize) + set_data_size(off_t data_size) { gold_assert(!this->is_data_size_valid_ && !this->is_data_size_fixed_); - this->data_size_ = datasize; + this->data_size_ = data_size; this->is_data_size_valid_ = true; } @@ -442,10 +442,10 @@ class Output_data // Set the current data size--this is for the convenience of // sections which build up their size over time. void - set_current_data_size_for_child(off_t datasize) + set_current_data_size_for_child(off_t data_size) { gold_assert(!this->is_data_size_valid_); - this->data_size_ = datasize; + this->data_size_ = data_size; } // Return default alignment for the target size. @@ -639,17 +639,17 @@ class Output_file_header : public Output_data class Output_section_data : public Output_data { public: - Output_section_data(off_t datasize, uint64_t addr_align, - bool is_datasize_fixed) - : Output_data(), output_section_(NULL), addralign_(addr_align) + Output_section_data(off_t data_size, uint64_t addralign, + bool is_data_size_fixed) + : Output_data(), output_section_(NULL), addralign_(addralign) { - this->set_data_size(datasize); - if (is_datasize_fixed) + this->set_data_size(data_size); + if (is_data_size_fixed) this->fix_data_size(); } - Output_section_data(uint64_t addr_align) - : Output_data(), output_section_(NULL), addralign_(addr_align) + Output_section_data(uint64_t addralign) + : Output_data(), output_section_(NULL), addralign_(addralign) { } // Return the output section. @@ -675,9 +675,9 @@ class Output_section_data : public Output_data // this input offset is being discarded. bool output_offset(const Relobj* object, unsigned int shndx, - section_offset_type sec_offset, + section_offset_type offset, section_offset_type *poutput) const - { return this->do_output_offset(object, shndx, sec_offset, poutput); } + { return this->do_output_offset(object, shndx, offset, poutput); } // Return whether this is the merge section for the input section // SHNDX in OBJECT. This should return true when output_offset @@ -768,8 +768,8 @@ class Output_section_data : public Output_data class Output_section_data_build : public Output_section_data { public: - Output_section_data_build(uint64_t addr_align) - : Output_section_data(addr_align) + Output_section_data_build(uint64_t addralign) + : Output_section_data(addralign) { } // Get the current data size. @@ -779,8 +779,8 @@ class Output_section_data_build : public Output_section_data // Set the current data size. void - set_current_data_size(off_t datasize) - { this->set_current_data_size_for_child(datasize); } + set_current_data_size(off_t data_size) + { this->set_current_data_size_for_child(data_size); } protected: // Set the final data size. @@ -795,16 +795,16 @@ class Output_section_data_build : public Output_section_data class Output_data_const : public Output_section_data { public: - Output_data_const(const std::string& data, uint64_t addr_align) - : Output_section_data(data.size(), addr_align, true), data_(data) + Output_data_const(const std::string& data, uint64_t addralign) + : Output_section_data(data.size(), addralign, true), data_(data) { } - Output_data_const(const char* p, off_t len, uint64_t addr_align) - : Output_section_data(len, addr_align, true), data_(p, len) + Output_data_const(const char* p, off_t len, uint64_t addralign) + : Output_section_data(len, addralign, true), data_(p, len) { } - Output_data_const(const unsigned char* p, off_t len, uint64_t addr_align) - : Output_section_data(len, addr_align, true), + Output_data_const(const unsigned char* p, off_t len, uint64_t addralign) + : Output_section_data(len, addralign, true), data_(reinterpret_cast<const char*>(p), len) { } @@ -834,8 +834,8 @@ class Output_data_const_buffer : public Output_section_data { public: Output_data_const_buffer(const unsigned char* p, off_t len, - uint64_t addr_align, const char* map_name) - : Output_section_data(len, addr_align, true), + uint64_t addralign, const char* map_name) + : Output_section_data(len, addralign, true), p_(p), map_name_(map_name) { } @@ -868,9 +868,9 @@ class Output_data_const_buffer : public Output_section_data class Output_data_fixed_space : public Output_section_data { public: - Output_data_fixed_space(off_t datasize, uint64_t addr_align, + Output_data_fixed_space(off_t data_size, uint64_t addralign, const char* map_name) - : Output_section_data(datasize, addr_align, true), + : Output_section_data(data_size, addralign, true), map_name_(map_name) { } @@ -898,8 +898,8 @@ class Output_data_fixed_space : public Output_section_data class Output_data_space : public Output_section_data_build { public: - explicit Output_data_space(uint64_t addr_align, const char* map_name) - : Output_section_data_build(addr_align), + explicit Output_data_space(uint64_t addralign, const char* map_name) + : Output_section_data_build(addralign), map_name_(map_name) { } @@ -932,8 +932,8 @@ class Output_data_space : public Output_section_data_build class Output_data_zero_fill : public Output_section_data { public: - Output_data_zero_fill(off_t datasize, uint64_t addr_align) - : Output_section_data(datasize, addr_align, true) + Output_data_zero_fill(off_t data_size, uint64_t addralign) + : Output_section_data(data_size, addralign, true) { } protected: @@ -1181,33 +1181,33 @@ class Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> // A reloc against a global symbol. Output_reloc(Symbol* gsym, unsigned int type, Output_data* od, - Address addr, Addend addend, bool is_relative) - : rel_(gsym, type, od, addr, is_relative), addend_(addend) + Address address, Addend addend, bool is_relative) + : rel_(gsym, type, od, address, is_relative), addend_(addend) { } Output_reloc(Symbol* gsym, unsigned int type, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr, Addend addend, + unsigned int shndx, Address address, Addend addend, bool is_relative) - : rel_(gsym, type, relobj, shndx, addr, is_relative), addend_(addend) + : rel_(gsym, type, relobj, shndx, address, is_relative), addend_(addend) { } // A reloc against a local symbol. Output_reloc(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, Address addr, + Output_data* od, Address address, Addend addend, bool is_relative, bool is_section_symbol) - : rel_(relobj, local_sym_index, type, od, addr, is_relative, + : rel_(relobj, local_sym_index, type, od, address, is_relative, is_section_symbol), addend_(addend) { } Output_reloc(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - unsigned int shndx, Address addr, + unsigned int shndx, Address address, Addend addend, bool is_relative, bool is_section_symbol) - : rel_(relobj, local_sym_index, type, shndx, addr, is_relative, + : rel_(relobj, local_sym_index, type, shndx, address, is_relative, is_section_symbol), addend_(addend) { } @@ -1215,14 +1215,14 @@ class Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> // A reloc against the STT_SECTION symbol of an output section. Output_reloc(Output_section* os, unsigned int type, Output_data* od, - Address addr, Addend addend) - : rel_(os, type, od, addr), addend_(addend) + Address address, Addend addend) + : rel_(os, type, od, address), addend_(addend) { } Output_reloc(Output_section* os, unsigned int type, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr, Addend addend) - : rel_(os, type, relobj, shndx, addr), addend_(addend) + unsigned int shndx, Address address, Addend addend) + : rel_(os, type, relobj, shndx, address), addend_(addend) { } // Write the reloc entry to an output view. @@ -1345,33 +1345,33 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> // Add a reloc against a global symbol. void - add_global(Symbol* gsym, unsigned int type, Output_data* od, Address addr) - { this->add(od, Output_reloc_type(gsym, type, od, addr, false)); } + add_global(Symbol* gsym, unsigned int type, Output_data* od, Address address) + { this->add(od, Output_reloc_type(gsym, type, od, address, false)); } void add_global(Symbol* gsym, unsigned int type, Output_data* od, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr) - { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, addr, + unsigned int shndx, Address address) + { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address, false)); } // These are to simplify the Copy_relocs class. void - add_global(Symbol* gsym, unsigned int type, Output_data* od, Address addr, + add_global(Symbol* gsym, unsigned int type, Output_data* od, Address address, Address addend) { gold_assert(addend == 0); - this->add_global(gsym, type, od, addr); + this->add_global(gsym, type, od, address); } void add_global(Symbol* gsym, unsigned int type, Output_data* od, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr, Address addend) + unsigned int shndx, Address address, Address addend) { gold_assert(addend == 0); - this->add_global(gsym, type, od, relobj, shndx, addr); + this->add_global(gsym, type, od, relobj, shndx, address); } // Add a RELATIVE reloc against a global symbol. The final relocation @@ -1379,15 +1379,15 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> void add_global_relative(Symbol* gsym, unsigned int type, Output_data* od, - Address addr) - { this->add(od, Output_reloc_type(gsym, type, od, addr, true)); } + Address address) + { this->add(od, Output_reloc_type(gsym, type, od, address, true)); } void add_global_relative(Symbol* gsym, unsigned int type, Output_data* od, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr) + unsigned int shndx, Address address) { - this->add(od, Output_reloc_type(gsym, type, relobj, shndx, addr, + this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address, true)); } @@ -1396,19 +1396,19 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> void add_local(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, Address addr) + Output_data* od, Address address) { this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, - addr, false, false)); + address, false, false)); } void add_local(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, unsigned int shndx, Address addr) + Output_data* od, unsigned int shndx, Address address) { this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx, - addr, false, false)); + address, false, false)); } // Add a RELATIVE reloc against a local symbol. @@ -1416,19 +1416,19 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> void add_local_relative(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, Address addr) + Output_data* od, Address address) { this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, - addr, true, false)); + address, true, false)); } void add_local_relative(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, unsigned int shndx, Address addr) + Output_data* od, unsigned int shndx, Address address) { this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx, - addr, true, false)); + address, true, false)); } // Add a reloc against a local section symbol. This will be @@ -1438,19 +1438,19 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> void add_local_section(Sized_relobj<size, big_endian>* relobj, unsigned int input_shndx, unsigned int type, - Output_data* od, Address addr) + Output_data* od, Address address) { this->add(od, Output_reloc_type(relobj, input_shndx, type, od, - addr, false, true)); + address, false, true)); } void add_local_section(Sized_relobj<size, big_endian>* relobj, unsigned int input_shndx, unsigned int type, - Output_data* od, unsigned int shndx, Address addr) + Output_data* od, unsigned int shndx, Address address) { this->add(od, Output_reloc_type(relobj, input_shndx, type, shndx, - addr, false, true)); + address, false, true)); } // A reloc against the STT_SECTION symbol of an output section. @@ -1459,14 +1459,14 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian> void add_output_section(Output_section* os, unsigned int type, - Output_data* od, Address addr) - { this->add(od, Output_reloc_type(os, type, od, addr)); } + Output_data* od, Address address) + { this->add(od, Output_reloc_type(os, type, od, address)); } void add_output_section(Output_section* os, unsigned int type, Output_data* od, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr) - { this->add(od, Output_reloc_type(os, type, relobj, shndx, addr)); } + unsigned int shndx, Address address) + { this->add(od, Output_reloc_type(os, type, relobj, shndx, address)); } }; // The SHT_RELA version of Output_data_reloc. @@ -1492,16 +1492,16 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> void add_global(Symbol* gsym, unsigned int type, Output_data* od, - Address addr, Addend addend) - { this->add(od, Output_reloc_type(gsym, type, od, addr, addend, + Address address, Addend addend) + { this->add(od, Output_reloc_type(gsym, type, od, address, addend, false)); } void add_global(Symbol* gsym, unsigned int type, Output_data* od, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr, + unsigned int shndx, Address address, Addend addend) - { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, addr, + { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address, addend, false)); } // Add a RELATIVE reloc against a global symbol. The final output @@ -1511,14 +1511,14 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> void add_global_relative(Symbol* gsym, unsigned int type, Output_data* od, - Address addr, Addend addend) - { this->add(od, Output_reloc_type(gsym, type, od, addr, addend, true)); } + Address address, Addend addend) + { this->add(od, Output_reloc_type(gsym, type, od, address, addend, true)); } void add_global_relative(Symbol* gsym, unsigned int type, Output_data* od, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr, Addend addend) - { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, addr, + unsigned int shndx, Address address, Addend addend) + { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address, addend, true)); } // Add a reloc against a local symbol. @@ -1526,20 +1526,20 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> void add_local(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, Address addr, Addend addend) + Output_data* od, Address address, Addend addend) { - this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, addr, + this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address, addend, false, false)); } void add_local(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, unsigned int shndx, Address addr, + Output_data* od, unsigned int shndx, Address address, Addend addend) { this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx, - addr, addend, false, false)); + address, addend, false, false)); } // Add a RELATIVE reloc against a local symbol. @@ -1547,20 +1547,20 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> void add_local_relative(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, Address addr, Addend addend) + Output_data* od, Address address, Addend addend) { - this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, addr, + this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address, addend, true, false)); } void add_local_relative(Sized_relobj<size, big_endian>* relobj, unsigned int local_sym_index, unsigned int type, - Output_data* od, unsigned int shndx, Address addr, + Output_data* od, unsigned int shndx, Address address, Addend addend) { this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx, - addr, addend, true, false)); + address, addend, true, false)); } // Add a reloc against a local section symbol. This will be @@ -1570,34 +1570,34 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian> void add_local_section(Sized_relobj<size, big_endian>* relobj, unsigned int input_shndx, unsigned int type, - Output_data* od, Address addr, Addend addend) + Output_data* od, Address address, Addend addend) { - this->add(od, Output_reloc_type(relobj, input_shndx, type, od, addr, + this->add(od, Output_reloc_type(relobj, input_shndx, type, od, address, addend, false, true)); } void add_local_section(Sized_relobj<size, big_endian>* relobj, unsigned int input_shndx, unsigned int type, - Output_data* od, unsigned int shndx, Address addr, + Output_data* od, unsigned int shndx, Address address, Addend addend) { this->add(od, Output_reloc_type(relobj, input_shndx, type, shndx, - addr, addend, false, true)); + address, addend, false, true)); } // A reloc against the STT_SECTION symbol of an output section. void add_output_section(Output_section* os, unsigned int type, Output_data* od, - Address addr, Addend addend) - { this->add(os, Output_reloc_type(os, type, od, addr, addend)); } + Address address, Addend addend) + { this->add(os, Output_reloc_type(os, type, od, address, addend)); } void add_output_section(Output_section* os, unsigned int type, Sized_relobj<size, big_endian>* relobj, - unsigned int shndx, Address addr, Addend addend) - { this->add(os, Output_reloc_type(os, type, relobj, shndx, addr, + unsigned int shndx, Address address, Addend addend) + { this->add(os, Output_reloc_type(os, type, relobj, shndx, address, addend)); } }; @@ -1866,8 +1866,8 @@ class Output_data_dynamic : public Output_section_data // plus a constant offset. void add_section_plus_offset(elfcpp::DT tag, const Output_data* od, - unsigned int sec_offset) - { this->add_entry(Dynamic_entry(tag, od, sec_offset)); } + unsigned int offset) + { this->add_entry(Dynamic_entry(tag, od, offset)); } // Add a new dynamic entry with the size of output data. void @@ -1912,32 +1912,32 @@ class Output_data_dynamic : public Output_section_data { public: // Create an entry with a fixed numeric value. - Dynamic_entry(elfcpp::DT etag, unsigned int val) - : tag_(etag), offset_(DYNAMIC_NUMBER) + Dynamic_entry(elfcpp::DT tag, unsigned int val) + : tag_(tag), offset_(DYNAMIC_NUMBER) { this->u_.val = val; } // Create an entry with the size or address of a section. - Dynamic_entry(elfcpp::DT etag, const Output_data* od, bool section_size) - : tag_(etag), + Dynamic_entry(elfcpp::DT tag, const Output_data* od, bool section_size) + : tag_(tag), offset_(section_size ? DYNAMIC_SECTION_SIZE : DYNAMIC_SECTION_ADDRESS) { this->u_.od = od; } // Create an entry with the address of a section plus a constant offset. - Dynamic_entry(elfcpp::DT etag, const Output_data* od, unsigned int offset) - : tag_(etag), + Dynamic_entry(elfcpp::DT tag, const Output_data* od, unsigned int offset) + : tag_(tag), offset_(offset) { this->u_.od = od; } // Create an entry with the address of a symbol. - Dynamic_entry(elfcpp::DT etag, const Symbol* sym) - : tag_(etag), offset_(DYNAMIC_SYMBOL) + Dynamic_entry(elfcpp::DT tag, const Symbol* sym) + : tag_(tag), offset_(DYNAMIC_SYMBOL) { this->u_.sym = sym; } // Create an entry with a string. - Dynamic_entry(elfcpp::DT etag, const char* str) - : tag_(etag), offset_(DYNAMIC_STRING) + Dynamic_entry(elfcpp::DT tag, const char* str) + : tag_(tag), offset_(DYNAMIC_STRING) { this->u_.str = str; } // Return the tag of this entry. @@ -2050,9 +2050,9 @@ class Output_relaxed_input_section : public Output_section_data_build // We would like to call relobj->section_addralign(shndx) to get the // alignment but we do not want the constructor to fail. So callers // are repsonsible for ensuring that. - Output_relaxed_input_section(Relobj* rel_obj, unsigned int sec_shndx, - uint64_t addr_align) - : Output_section_data_build(addr_align), relobj_(rel_obj), shndx_(sec_shndx) + Output_relaxed_input_section(Relobj* relobj, unsigned int shndx, + uint64_t addralign) + : Output_section_data_build(addralign), relobj_(relobj), shndx_(shndx) { } // Return the Relobj of this relaxed input section. @@ -2132,9 +2132,9 @@ class Output_section : public Output_data // Set the load address. void - set_load_address(uint64_t load_addr) + set_load_address(uint64_t load_address) { - this->load_address_ = load_addr; + this->load_address_ = load_address; this->has_load_address_ = true; } @@ -2502,11 +2502,11 @@ class Output_section : public Output_data static const unsigned int invalid_shndx = static_cast<unsigned int>(-1); public: - Simple_input_section(Relobj *rel_obj, unsigned int sec_shndx) - : shndx_(sec_shndx) + Simple_input_section(Relobj *relobj, unsigned int shndx) + : shndx_(shndx) { - gold_assert(sec_shndx != invalid_shndx); - this->u_.relobj = rel_obj; + gold_assert(shndx != invalid_shndx); + this->u_.relobj = relobj; } Simple_input_section(Output_relaxed_input_section* section) @@ -2676,8 +2676,8 @@ class Output_section : public Output_data // Return whether this is a section of the specified type. bool - do_is_section_type(elfcpp::Elf_Word sec_type) const - { return this->type_ == sec_type; } + do_is_section_type(elfcpp::Elf_Word type) const + { return this->type_ == type; } // Return whether the specified section flag is set. bool @@ -2738,16 +2738,16 @@ class Output_section : public Output_data } // For an ordinary input section. - Input_section(Relobj* object, unsigned int sec_shndx, off_t datasize, - uint64_t addr_align) - : shndx_(sec_shndx), - p2align_(ffsll(static_cast<long long>(addr_align))) + Input_section(Relobj* object, unsigned int shndx, off_t data_size, + uint64_t addralign) + : shndx_(shndx), + p2align_(ffsll(static_cast<long long>(addralign))) { - gold_assert(sec_shndx != OUTPUT_SECTION_CODE - && sec_shndx != MERGE_DATA_SECTION_CODE - && sec_shndx != MERGE_STRING_SECTION_CODE - && sec_shndx != RELAXED_INPUT_SECTION_CODE); - this->u1_.data_size = datasize; + gold_assert(shndx != OUTPUT_SECTION_CODE + && shndx != MERGE_DATA_SECTION_CODE + && shndx != MERGE_STRING_SECTION_CODE + && shndx != RELAXED_INPUT_SECTION_CODE); + this->u1_.data_size = data_size; this->u2_.object = object; } @@ -2807,13 +2807,13 @@ class Output_section : public Output_data // parameters. bool is_merge_section(bool is_string, uint64_t entsize, - uint64_t addr_align) const + uint64_t addralign) const { return (this->shndx_ == (is_string ? MERGE_STRING_SECTION_CODE : MERGE_DATA_SECTION_CODE) && this->u1_.entsize == entsize - && this->addralign() == addr_align); + && this->addralign() == addralign); } // Return whether this is a relaxed input section. @@ -2896,11 +2896,11 @@ class Output_section : public Output_data // Add an input section, for SHF_MERGE sections. bool - add_input_section(Relobj* object, unsigned int sec_shndx) + add_input_section(Relobj* object, unsigned int shndx) { gold_assert(this->shndx_ == MERGE_DATA_SECTION_CODE || this->shndx_ == MERGE_STRING_SECTION_CODE); - return this->u2_.posd->add_input_section(object, sec_shndx); + return this->u2_.posd->add_input_section(object, shndx); } // Given an input OBJECT, an input section index SHNDX within that @@ -3000,15 +3000,15 @@ class Output_section : public Output_data class Checkpoint_output_section { public: - Checkpoint_output_section(uint64_t addr_align, elfcpp::Elf_Xword sflags, - const Input_section_list& sinput_sections, - off_t first_input_off, - bool attached_input_sections_sorted) - : addralign_(addr_align), flags_(sflags), - input_sections_(sinput_sections), + Checkpoint_output_section(uint64_t addralign, elfcpp::Elf_Xword flags, + const Input_section_list& input_sections, + off_t first_input_offset, + bool attached_input_sections_are_sorted) + : addralign_(addralign), flags_(flags), + input_sections_(input_sections), input_sections_size_(input_sections_.size()), - input_sections_copy_(), first_input_offset_(first_input_off), - attached_input_sections_are_sorted_(attached_input_sections_sorted) + input_sections_copy_(), first_input_offset_(first_input_offset), + attached_input_sections_are_sorted_(attached_input_sections_are_sorted) { } virtual @@ -3098,9 +3098,9 @@ class Output_section : public Output_data class Fill { public: - Fill(off_t section_off, off_t len) - : section_offset_(section_off), - length_(convert_to_section_size_type(len)) + Fill(off_t section_offset, off_t length) + : section_offset_(section_offset), + length_(convert_to_section_size_type(length)) { } // Return section offset. @@ -3467,18 +3467,18 @@ class Output_segment // Set the addresses. void - set_addresses(uint64_t v_addr, uint64_t p_addr) + set_addresses(uint64_t vaddr, uint64_t paddr) { - this->vaddr_ = v_addr; - this->paddr_ = p_addr; + this->vaddr_ = vaddr; + this->paddr_ = paddr; this->are_addresses_set_ = true; } // Set the segment flags. This is only used if we have a PHDRS // clause which explicitly specifies the flags. void - set_flags(elfcpp::Elf_Word seg_flags) - { this->flags_ = seg_flags; } + set_flags(elfcpp::Elf_Word flags) + { this->flags_ = flags; } // Set the address of the segment to ADDR and the offset to *POFF // and set the addresses and offsets of all contained output diff --git a/gold/parameters.cc b/gold/parameters.cc index cd08c62..2a53998 100644 --- a/gold/parameters.cc +++ b/gold/parameters.cc @@ -1,6 +1,6 @@ // parameters.cc -- general parameters for a link using gold -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -31,50 +31,50 @@ namespace gold { void -Parameters::set_errors(Errors* errs) +Parameters::set_errors(Errors* errors) { gold_assert(this->errors_ == NULL); - this->errors_ = errs; + this->errors_ = errors; } void -Parameters::set_options(const General_options* opts) +Parameters::set_options(const General_options* options) { gold_assert(!this->options_valid()); - this->options_ = opts; + this->options_ = options; // For speed, we convert the options() debug var from a string to an // enum (from debug.h). this->debug_ = debug_string_to_enum(this->options().debug()); // If --verbose is set, it acts as "--debug=files". - if (opts->verbose()) + if (options->verbose()) this->debug_ |= DEBUG_FILES; } void -Parameters::set_doing_static_link(bool doing_staticlink) +Parameters::set_doing_static_link(bool doing_static_link) { gold_assert(!this->doing_static_link_valid_); - this->doing_static_link_ = doing_staticlink; + this->doing_static_link_ = doing_static_link; this->doing_static_link_valid_ = true; } void -Parameters::set_target(Target* targ) +Parameters::set_target(Target* target) { if (!this->target_valid()) - this->target_ = targ; + this->target_ = target; else - gold_assert(targ == this->target_); + gold_assert(target == this->target_); } // Return whether TARGET is compatible with the target we are using. bool -Parameters::is_compatible_target(const Target* targ) const +Parameters::is_compatible_target(const Target* target) const { if (this->target_ == NULL) return true; - return targ == this->target_; + return target == this->target_; } Parameters::Target_size_endianness diff --git a/gold/plugin.cc b/gold/plugin.cc index de676eb..ff9f98f 100644 --- a/gold/plugin.cc +++ b/gold/plugin.cc @@ -318,7 +318,7 @@ Plugin_manager::claim_file(Input_file* input_file, off_t offset, void Plugin_manager::all_symbols_read(Workqueue* workqueue, Task* task, Input_objects* input_objects, - Symbol_table* symtab, Layout* alayout, + Symbol_table* symtab, Layout* layout, Dirsearch* dirpath, Mapfile* mapfile, Task_token** last_blocker) { @@ -327,7 +327,7 @@ Plugin_manager::all_symbols_read(Workqueue* workqueue, Task* task, this->task_ = task; this->input_objects_ = input_objects; this->symtab_ = symtab; - this->layout_ = alayout; + this->layout_ = layout; this->dirpath_ = dirpath; this->mapfile_ = mapfile; this->this_blocker_ = NULL; @@ -446,10 +446,10 @@ Plugin_manager::add_input_file(char *pathname, bool is_lib) // Class Pluginobj. -Pluginobj::Pluginobj(const std::string& aname, Input_file* ainput_file, - off_t aoffset, off_t afilesize) - : Object(aname, ainput_file, false, aoffset), - nsyms_(0), syms_(NULL), symbols_(), filesize_(afilesize), comdat_map_() +Pluginobj::Pluginobj(const std::string& name, Input_file* input_file, + off_t offset, off_t filesize) + : Object(name, input_file, false, offset), + nsyms_(0), syms_(NULL), symbols_(), filesize_(filesize), comdat_map_() { } @@ -521,7 +521,7 @@ Pluginobj::get_symbol_resolution_info(int nsyms, ld_plugin_symbol* syms) const // should be kept. bool -Pluginobj::include_comdat_group(std::string comdat_key, Layout* alayout) +Pluginobj::include_comdat_group(std::string comdat_key, Layout* layout) { std::pair<Comdat_map::iterator, bool> ins = this->comdat_map_.insert(std::make_pair(comdat_key, false)); @@ -529,9 +529,9 @@ Pluginobj::include_comdat_group(std::string comdat_key, Layout* alayout) // If this is the first time we've seen this comdat key, ask the // layout object whether it should be included. if (ins.second) - ins.first->second = alayout->find_or_add_kept_section(comdat_key, - NULL, 0, true, - true, NULL); + ins.first->second = layout->find_or_add_kept_section(comdat_key, + NULL, 0, true, + true, NULL); return ins.first->second; } @@ -540,11 +540,11 @@ Pluginobj::include_comdat_group(std::string comdat_key, Layout* alayout) template<int size, bool big_endian> Sized_pluginobj<size, big_endian>::Sized_pluginobj( - const std::string& aname, - Input_file* ainput_file, - off_t aoffset, - off_t afilesize) - : Pluginobj(aname, ainput_file, aoffset, afilesize) + const std::string& name, + Input_file* input_file, + off_t offset, + off_t filesize) + : Pluginobj(name, input_file, offset, filesize) { } @@ -573,7 +573,7 @@ template<int size, bool big_endian> void Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, Read_symbols_data*, - Layout* alayout) + Layout* layout) { const int sym_size = elfcpp::Elf_sizes<size>::sym_size; unsigned char symbuf[sym_size]; @@ -587,14 +587,14 @@ Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, for (int i = 0; i < this->nsyms_; ++i) { const struct ld_plugin_symbol *isym = &this->syms_[i]; - const char* aname = isym->name; + const char* name = isym->name; const char* ver = isym->version; elfcpp::Elf_Half shndx; elfcpp::STB bind; elfcpp::STV vis; - if (aname != NULL && aname[0] == '\0') - aname = NULL; + if (name != NULL && name[0] == '\0') + name = NULL; if (ver != NULL && ver[0] == '\0') ver = NULL; @@ -647,7 +647,7 @@ Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, if (isym->comdat_key != NULL && isym->comdat_key[0] != '\0' - && !this->include_comdat_group(isym->comdat_key, alayout)) + && !this->include_comdat_group(isym->comdat_key, layout)) shndx = elfcpp::SHN_UNDEF; osym.put_st_name(0); @@ -658,7 +658,7 @@ Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, osym.put_st_shndx(shndx); this->symbols_[i] = - symtab->add_from_pluginobj<size, big_endian>(this, aname, ver, &sym); + symtab->add_from_pluginobj<size, big_endian>(this, name, ver, &sym); } } diff --git a/gold/powerpc.cc b/gold/powerpc.cc index 8bb633f..bd5571c 100644 --- a/gold/powerpc.cc +++ b/gold/powerpc.cc @@ -890,10 +890,10 @@ template<int size, bool big_endian> void Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of) { - const off_t off = this->offset(); + const off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); unsigned char* pov = oview; memset(pov, 0, base_plt_entry_size * 4); @@ -924,7 +924,7 @@ Output_data_plt_powerpc<size, big_endian>::do_write(Output_file* of) gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); } // Create a PLT entry for a global symbol. @@ -1458,9 +1458,9 @@ Target_powerpc<size, big_endian>::gc_process_relocs( const unsigned char* plocal_symbols) { typedef Target_powerpc<size, big_endian> Powerpc; - typedef typename Target_powerpc<size, big_endian>::Scan scan; + typedef typename Target_powerpc<size, big_endian>::Scan Scan; - gold::gc_process_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, scan>( + gold::gc_process_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>( symtab, layout, this, @@ -1492,7 +1492,7 @@ Target_powerpc<size, big_endian>::scan_relocs( const unsigned char* plocal_symbols) { typedef Target_powerpc<size, big_endian> Powerpc; - typedef typename Target_powerpc<size, big_endian>::Scan scan; + typedef typename Target_powerpc<size, big_endian>::Scan Scan; static Output_data_space* sdata; if (sh_type == elfcpp::SHT_REL) @@ -1520,7 +1520,7 @@ Target_powerpc<size, big_endian>::scan_relocs( false, false); } - gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, scan>( + gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>( symtab, layout, this, @@ -1992,17 +1992,17 @@ public: (big_endian ? "elf32-powerpc" : "elf32-powerpcle"))) { } - Target* do_recognize(int amachine, int, int) + Target* do_recognize(int machine, int, int) { switch (size) { case 64: - if (amachine != elfcpp::EM_PPC64) + if (machine != elfcpp::EM_PPC64) return NULL; break; case 32: - if (amachine != elfcpp::EM_PPC) + if (machine != elfcpp::EM_PPC) return NULL; break; diff --git a/gold/reduced_debug_output.cc b/gold/reduced_debug_output.cc index d2b0e3d..5bc8053 100644 --- a/gold/reduced_debug_output.cc +++ b/gold/reduced_debug_output.cc @@ -1,6 +1,6 @@ // reduced_debug_output.cc -- output reduced debugging information to save space -// Copyright 2008, 2009 Free Software Foundation, Inc. +// Copyright 2008 Free Software Foundation, Inc. // Written by Caleb Howe <cshowe@google.com>. // This file is part of gold. @@ -213,15 +213,15 @@ Output_reduced_debug_abbrev_section::set_final_data_size() void Output_reduced_debug_abbrev_section::do_write(Output_file* of) { - off_t off = this->offset(); - off_t datasize = this->data_size(); - unsigned char* view = of->get_output_view(off, datasize); + off_t offset = this->offset(); + off_t data_size = this->data_size(); + unsigned char* view = of->get_output_view(offset, data_size); if (this->failed_) memcpy(view, this->postprocessing_buffer(), this->postprocessing_buffer_size()); else - memcpy(view, &this->data_.front(), datasize); - of->write_output_view(off, datasize, view); + memcpy(view, &this->data_.front(), data_size); + of->write_output_view(offset, data_size, view); } // Locates the abbreviation with abbreviation_number abbrev_number in the @@ -353,15 +353,15 @@ void Output_reduced_debug_info_section::set_final_data_size() void Output_reduced_debug_info_section::do_write(Output_file* of) { - off_t off = this->offset(); - off_t datasize = this->data_size(); - unsigned char* view = of->get_output_view(off, datasize); + off_t offset = this->offset(); + off_t data_size = this->data_size(); + unsigned char* view = of->get_output_view(offset, data_size); if (this->failed_) memcpy(view, this->postprocessing_buffer(), this->postprocessing_buffer_size()); else - memcpy(view, &this->data_.front(), datasize); - of->write_output_view(off, datasize, view); + memcpy(view, &this->data_.front(), data_size); + of->write_output_view(offset, data_size, view); } } // End namespace gold. diff --git a/gold/reduced_debug_output.h b/gold/reduced_debug_output.h index e6a083c..d168228 100644 --- a/gold/reduced_debug_output.h +++ b/gold/reduced_debug_output.h @@ -1,6 +1,6 @@ // reduced_debug_output.h -- reduce debugging information -*- C++ -*- -// Copyright 2008, 2009 Free Software Foundation, Inc. +// Copyright 2008 Free Software Foundation, Inc. // Written by Caleb Howe <cshowe@google.com>. // This file is part of gold. @@ -42,9 +42,9 @@ namespace gold class Output_reduced_debug_abbrev_section : public Output_section { public: - Output_reduced_debug_abbrev_section(const char* aname, elfcpp::Elf_Word aflags, - elfcpp::Elf_Xword atype) - : Output_section(aname, aflags, atype), sized_(false), + Output_reduced_debug_abbrev_section(const char* name, elfcpp::Elf_Word flags, + elfcpp::Elf_Xword type) + : Output_section(name, flags, type), sized_(false), abbrev_count_(0), failed_(false) { this->set_requires_postprocessing(); } @@ -88,9 +88,9 @@ class Output_reduced_debug_abbrev_section : public Output_section class Output_reduced_debug_info_section : public Output_section { public: - Output_reduced_debug_info_section(const char* aname, elfcpp::Elf_Word aflags, - elfcpp::Elf_Xword atype) - : Output_section(aname, aflags, atype), failed_(false) + Output_reduced_debug_info_section(const char* name, elfcpp::Elf_Word flags, + elfcpp::Elf_Xword type) + : Output_section(name, flags, type), failed_(false) { this->set_requires_postprocessing(); } void diff --git a/gold/reloc.cc b/gold/reloc.cc index dfe50b3..858778e 100644 --- a/gold/reloc.cc +++ b/gold/reloc.cc @@ -239,21 +239,21 @@ Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd) { rd->relocs.clear(); - unsigned int sec_shnum = this->shnum(); - if (sec_shnum == 0) + unsigned int shnum = this->shnum(); + if (shnum == 0) return; - rd->relocs.reserve(sec_shnum / 2); + rd->relocs.reserve(shnum / 2); 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(), - sec_shnum * This::shdr_size, + shnum * This::shdr_size, true, true); // Skip the first, dummy, section. const unsigned char *ps = pshdrs + This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, ps += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, ps += This::shdr_size) { typename This::Shdr shdr(ps); @@ -262,7 +262,7 @@ Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd) continue; unsigned int shndx = this->adjust_shndx(shdr.get_sh_info()); - if (shndx >= sec_shnum) + if (shndx >= shnum) { this->error(_("relocation section %u has bad info %u"), i, shndx); @@ -341,10 +341,10 @@ Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd) typename This::Shdr symtabshdr(pshdrs + this->symtab_shndx_ * This::shdr_size); gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); - const int symsize = This::sym_size; + const int sym_size = This::sym_size; const unsigned int loccount = this->local_symbol_count_; gold_assert(loccount == symtabshdr.get_sh_info()); - off_t locsize = loccount * symsize; + off_t locsize = loccount * sym_size; rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(), locsize, true, true); } @@ -357,7 +357,7 @@ Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd) template<int size, bool big_endian> void Sized_relobj<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd) { Sized_target<size, big_endian>* target = @@ -379,7 +379,7 @@ Sized_relobj<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab, // only scan allocated sections. We may see a non-allocated // section here if we are emitting relocs. if (p->is_data_section_allocated) - target->gc_process_relocs(symtab, alayout, this, + target->gc_process_relocs(symtab, layout, this, p->data_shndx, p->sh_type, p->contents->data(), p->reloc_count, p->output_section, @@ -397,7 +397,7 @@ Sized_relobj<size, big_endian>::do_gc_process_relocs(Symbol_table* symtab, template<int size, bool big_endian> void Sized_relobj<size, big_endian>::do_scan_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd) { Sized_target<size, big_endian>* target = @@ -428,21 +428,21 @@ Sized_relobj<size, big_endian>::do_scan_relocs(Symbol_table* symtab, // only scan allocated sections. We may see a non-allocated // section here if we are emitting relocs. if (p->is_data_section_allocated) - target->scan_relocs(symtab, alayout, this, p->data_shndx, + target->scan_relocs(symtab, layout, this, p->data_shndx, p->sh_type, p->contents->data(), p->reloc_count, p->output_section, p->needs_special_offset_handling, this->local_symbol_count_, local_symbols); if (parameters->options().emit_relocs()) - this->emit_relocs_scan(symtab, alayout, local_symbols, p); + this->emit_relocs_scan(symtab, layout, local_symbols, p); } else { Relocatable_relocs* rr = this->relocatable_relocs(p->reloc_shndx); gold_assert(rr != NULL); rr->set_reloc_count(p->reloc_count); - target->scan_relocatable_relocs(symtab, alayout, this, + target->scan_relocatable_relocs(symtab, layout, this, p->data_shndx, p->sh_type, p->contents->data(), p->reloc_count, @@ -505,7 +505,7 @@ template<int size, bool big_endian> void Sized_relobj<size, big_endian>::emit_relocs_scan( Symbol_table* symtab, - Layout* alayout, + Layout* layout, const unsigned char* plocal_syms, const Read_relocs_data::Relocs_list::iterator& p) { @@ -514,12 +514,12 @@ Sized_relobj<size, big_endian>::emit_relocs_scan( rr->set_reloc_count(p->reloc_count); if (p->sh_type == elfcpp::SHT_REL) - this->emit_relocs_scan_reltype<elfcpp::SHT_REL>(symtab, alayout, + this->emit_relocs_scan_reltype<elfcpp::SHT_REL>(symtab, layout, plocal_syms, p, rr); else { gold_assert(p->sh_type == elfcpp::SHT_RELA); - this->emit_relocs_scan_reltype<elfcpp::SHT_RELA>(symtab, alayout, + this->emit_relocs_scan_reltype<elfcpp::SHT_RELA>(symtab, layout, plocal_syms, p, rr); } } @@ -532,7 +532,7 @@ template<int sh_type> void Sized_relobj<size, big_endian>::emit_relocs_scan_reltype( Symbol_table* symtab, - Layout* alayout, + Layout* layout, const unsigned char* plocal_syms, const Read_relocs_data::Relocs_list::iterator& p, Relocatable_relocs* rr) @@ -540,7 +540,7 @@ Sized_relobj<size, big_endian>::emit_relocs_scan_reltype( scan_relocatable_relocs<size, big_endian, sh_type, Emit_relocs_strategy<sh_type> >( symtab, - alayout, + layout, this, p->data_shndx, p->contents->data(), @@ -557,18 +557,18 @@ Sized_relobj<size, big_endian>::emit_relocs_scan_reltype( template<int size, bool big_endian> void Sized_relobj<size, big_endian>::do_relocate(const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, Output_file* of) { - unsigned int sec_shnum = this->shnum(); + unsigned int shnum = this->shnum(); // Read the section headers. const unsigned char* pshdrs = this->get_view(this->elf_file_.shoff(), - sec_shnum * This::shdr_size, + shnum * This::shdr_size, true, true); Views views; - views.resize(sec_shnum); + views.resize(shnum); // Make two passes over the sections. The first one copies the // section data to the output file. The second one applies @@ -582,14 +582,14 @@ Sized_relobj<size, big_endian>::do_relocate(const Symbol_table* symtab, // Apply relocations. - this->relocate_sections(symtab, alayout, pshdrs, &views); + this->relocate_sections(symtab, layout, pshdrs, &views); // After we've done the relocations, we release the hash tables, // since we no longer need them. this->free_input_to_output_maps(); // Write out the accumulated views. - for (unsigned int i = 1; i < sec_shnum; ++i) + for (unsigned int i = 1; i < shnum; ++i) { if (views[i].view != NULL) { @@ -607,8 +607,8 @@ Sized_relobj<size, big_endian>::do_relocate(const Symbol_table* symtab, } // Write out the local symbols. - this->write_local_symbols(of, alayout->sympool(), alayout->dynpool(), - alayout->symtab_xindex(), alayout->dynsym_xindex()); + this->write_local_symbols(of, layout->sympool(), layout->dynpool(), + layout->symtab_xindex(), layout->dynsym_xindex()); // We should no longer need the local symbol values. this->clear_local_symbols(); @@ -633,7 +633,7 @@ Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs, Output_file* of, Views* pviews) { - unsigned int sec_shnum = this->shnum(); + unsigned int shnum = this->shnum(); const Output_sections& out_sections(this->output_sections()); const std::vector<Address>& out_offsets(this->section_offsets_); @@ -641,7 +641,7 @@ Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs, bool is_sorted = true; const unsigned char* p = pshdrs + This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, p += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) { View_size* pvs = &(*pviews)[i]; @@ -702,16 +702,16 @@ Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs, // buffer, and the output section is responsible for writing the // final data to the output file. - off_t out_section_offset; + off_t output_section_offset; Address output_section_size; if (!os->requires_postprocessing()) { - out_section_offset = os->offset(); + output_section_offset = os->offset(); output_section_size = convert_types<Address, off_t>(os->data_size()); } else { - out_section_offset = 0; + output_section_offset = 0; output_section_size = convert_types<Address, off_t>(os->postprocessing_buffer_size()); } @@ -720,12 +720,12 @@ Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs, section_size_type view_size; if (output_offset != invalid_address) { - view_start = out_section_offset + output_offset; + view_start = output_section_offset + output_offset; view_size = convert_to_section_size_type(shdr.get_sh_size()); } else { - view_start = out_section_offset; + view_start = output_section_offset; view_size = convert_to_section_size_type(output_section_size); } @@ -735,36 +735,36 @@ Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs, gold_assert(output_offset == invalid_address || output_offset + view_size <= output_section_size); - unsigned char* aview; + unsigned char* view; if (os->requires_postprocessing()) { unsigned char* buffer = os->postprocessing_buffer(); - aview = buffer + view_start; + view = buffer + view_start; if (output_offset != invalid_address) { off_t sh_offset = shdr.get_sh_offset(); if (!rm.empty() && rm.back().file_offset > sh_offset) is_sorted = false; rm.push_back(File_read::Read_multiple_entry(sh_offset, - view_size, aview)); + view_size, view)); } } else { if (output_offset == invalid_address) - aview = of->get_input_output_view(view_start, view_size); + view = of->get_input_output_view(view_start, view_size); else { - aview = of->get_output_view(view_start, view_size); + view = of->get_output_view(view_start, view_size); off_t sh_offset = shdr.get_sh_offset(); if (!rm.empty() && rm.back().file_offset > sh_offset) is_sorted = false; rm.push_back(File_read::Read_multiple_entry(sh_offset, - view_size, aview)); + view_size, view)); } } - pvs->view = aview; + pvs->view = view; pvs->address = os->address(); if (output_offset != invalid_address) pvs->address += output_offset; @@ -790,11 +790,11 @@ template<int size, bool big_endian> void Sized_relobj<size, big_endian>::do_relocate_sections( const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, const unsigned char* pshdrs, Views* pviews) { - unsigned int sec_shnum = this->shnum(); + unsigned int shnum = this->shnum(); Sized_target<size, big_endian>* target = parameters->sized_target<size, big_endian>(); @@ -803,11 +803,11 @@ Sized_relobj<size, big_endian>::do_relocate_sections( Relocate_info<size, big_endian> relinfo; relinfo.symtab = symtab; - relinfo.layout = alayout; + relinfo.layout = layout; relinfo.object = this; const unsigned char* p = pshdrs + This::shdr_size; - for (unsigned int i = 1; i < sec_shnum; ++i, p += This::shdr_size) + for (unsigned int i = 1; i < shnum; ++i, p += This::shdr_size) { typename This::Shdr shdr(p); @@ -880,7 +880,7 @@ Sized_relobj<size, big_endian>::do_relocate_sections( relinfo.reloc_shdr = p; relinfo.data_shndx = index; relinfo.data_shdr = pshdrs + index * This::shdr_size; - unsigned char* aview = (*pviews)[index].view; + unsigned char* view = (*pviews)[index].view; Address address = (*pviews)[index].address; section_size_type view_size = (*pviews)[index].view_size; @@ -890,7 +890,7 @@ Sized_relobj<size, big_endian>::do_relocate_sections( typename This::Shdr data_shdr(pshdrs + index * This::shdr_size); if ((data_shdr.get_sh_flags() & elfcpp::SHF_EXECINSTR) != 0) this->split_stack_adjust(symtab, pshdrs, sh_type, index, - prelocs, reloc_count, aview, view_size, + prelocs, reloc_count, view, view_size, &reloc_map); } @@ -898,10 +898,10 @@ Sized_relobj<size, big_endian>::do_relocate_sections( { target->relocate_section(&relinfo, sh_type, prelocs, reloc_count, os, output_offset == invalid_address, - aview, address, view_size, reloc_map); + view, address, view_size, reloc_map); if (parameters->options().emit_relocs()) this->emit_relocs(&relinfo, i, sh_type, prelocs, reloc_count, - os, output_offset, aview, address, view_size, + os, output_offset, view, address, view_size, (*pviews)[i].view, (*pviews)[i].view_size); } else @@ -909,7 +909,7 @@ Sized_relobj<size, big_endian>::do_relocate_sections( Relocatable_relocs* rr = this->relocatable_relocs(i); target->relocate_for_relocatable(&relinfo, sh_type, prelocs, reloc_count, os, output_offset, rr, - aview, address, view_size, + view, address, view_size, (*pviews)[i].view, (*pviews)[i].view_size); } @@ -926,9 +926,9 @@ Sized_relobj<size, big_endian>::emit_relocs( unsigned int sh_type, const unsigned char* prelocs, size_t reloc_count, - Output_section* aoutput_section, + Output_section* output_section, typename elfcpp::Elf_types<size>::Elf_Addr offset_in_output_section, - unsigned char* aview, + unsigned char* view, typename elfcpp::Elf_types<size>::Elf_Addr address, section_size_type view_size, unsigned char* reloc_view, @@ -936,17 +936,17 @@ Sized_relobj<size, big_endian>::emit_relocs( { if (sh_type == elfcpp::SHT_REL) this->emit_relocs_reltype<elfcpp::SHT_REL>(relinfo, i, prelocs, - reloc_count, aoutput_section, + reloc_count, output_section, offset_in_output_section, - aview, address, view_size, + view, address, view_size, reloc_view, reloc_view_size); else { gold_assert(sh_type == elfcpp::SHT_RELA); this->emit_relocs_reltype<elfcpp::SHT_RELA>(relinfo, i, prelocs, - reloc_count, aoutput_section, + reloc_count, output_section, offset_in_output_section, - aview, address, view_size, + view, address, view_size, reloc_view, reloc_view_size); } } @@ -962,9 +962,9 @@ Sized_relobj<size, big_endian>::emit_relocs_reltype( unsigned int i, const unsigned char* prelocs, size_t reloc_count, - Output_section* aoutput_section, + Output_section* output_section, typename elfcpp::Elf_types<size>::Elf_Addr offset_in_output_section, - unsigned char* aview, + unsigned char* view, typename elfcpp::Elf_types<size>::Elf_Addr address, section_size_type view_size, unsigned char* reloc_view, @@ -975,10 +975,10 @@ Sized_relobj<size, big_endian>::emit_relocs_reltype( relinfo, prelocs, reloc_count, - aoutput_section, + output_section, offset_in_output_section, rr, - aview, + view, address, view_size, reloc_view, @@ -1029,21 +1029,21 @@ Sized_relobj<size, big_endian>::split_stack_adjust( unsigned int shndx, const unsigned char* prelocs, size_t reloc_count, - unsigned char* aview, + unsigned char* view, section_size_type view_size, Reloc_symbol_changes** reloc_map) { if (sh_type == elfcpp::SHT_REL) this->split_stack_adjust_reltype<elfcpp::SHT_REL>(symtab, pshdrs, shndx, prelocs, reloc_count, - aview, view_size, + view, view_size, reloc_map); else { gold_assert(sh_type == elfcpp::SHT_RELA); this->split_stack_adjust_reltype<elfcpp::SHT_RELA>(symtab, pshdrs, shndx, prelocs, reloc_count, - aview, view_size, + view, view_size, reloc_map); } } @@ -1060,7 +1060,7 @@ Sized_relobj<size, big_endian>::split_stack_adjust_reltype( unsigned int shndx, const unsigned char* prelocs, size_t reloc_count, - unsigned char* aview, + unsigned char* view, section_size_type view_size, Reloc_symbol_changes** reloc_map) { @@ -1097,9 +1097,9 @@ Sized_relobj<size, big_endian>::split_stack_adjust_reltype( && gsym->source() == Symbol::FROM_OBJECT && !gsym->object()->uses_split_stack()) { - section_offset_type off = + section_offset_type offset = convert_to_section_size_type(reloc.get_r_offset()); - non_split_refs.push_back(off); + non_split_refs.push_back(offset); } } @@ -1152,7 +1152,7 @@ Sized_relobj<size, big_endian>::split_stack_adjust_reltype( std::string from; std::string to; parameters->target().calls_non_split(this, shndx, p->first, p->second, - aview, view_size, &from, &to); + view, view_size, &from, &to); if (!from.empty()) { gold_assert(!to.empty()); @@ -1171,10 +1171,10 @@ Sized_relobj<size, big_endian>::split_stack_adjust_reltype( if (r_sym < local_count) continue; - section_offset_type off = + section_offset_type offset = convert_to_section_size_type(reloc.get_r_offset()); - if (off < p->first - || (off + if (offset < p->first + || (offset >= (p->first + static_cast<section_offset_type>(p->second)))) continue; @@ -1216,8 +1216,8 @@ Sized_relobj<size, big_endian>::find_functions( // We need to read the symbols to find the functions. If we wanted // to, we could cache reading the symbols across all sections in the // object. - const unsigned int sym_tab_shndx = this->symtab_shndx_; - typename This::Shdr symtabshdr(pshdrs + sym_tab_shndx * This::shdr_size); + const unsigned int symtab_shndx = this->symtab_shndx_; + typename This::Shdr symtabshdr(pshdrs + symtab_shndx * This::shdr_size); gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB); typename elfcpp::Elf_types<size>::Elf_WXword sh_size = @@ -1225,9 +1225,9 @@ Sized_relobj<size, big_endian>::find_functions( const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(), sh_size, true, true); - const int symsize = This::sym_size; - const unsigned int symcount = sh_size / symsize; - for (unsigned int i = 0; i < symcount; ++i, psyms += symsize) + const int sym_size = This::sym_size; + const unsigned int symcount = sh_size / sym_size; + for (unsigned int i = 0; i < symcount; ++i, psyms += sym_size) { typename elfcpp::Sym<size, big_endian> isym(psyms); @@ -1419,7 +1419,7 @@ Sized_relobj<64, true>::do_read_relocs(Read_relocs_data* rd); template void Sized_relobj<32, false>::do_gc_process_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1427,7 +1427,7 @@ Sized_relobj<32, false>::do_gc_process_relocs(Symbol_table* symtab, template void Sized_relobj<32, true>::do_gc_process_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1435,7 +1435,7 @@ Sized_relobj<32, true>::do_gc_process_relocs(Symbol_table* symtab, template void Sized_relobj<64, false>::do_gc_process_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1443,7 +1443,7 @@ Sized_relobj<64, false>::do_gc_process_relocs(Symbol_table* symtab, template void Sized_relobj<64, true>::do_gc_process_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1451,7 +1451,7 @@ Sized_relobj<64, true>::do_gc_process_relocs(Symbol_table* symtab, template void Sized_relobj<32, false>::do_scan_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1459,7 +1459,7 @@ Sized_relobj<32, false>::do_scan_relocs(Symbol_table* symtab, template void Sized_relobj<32, true>::do_scan_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1467,7 +1467,7 @@ Sized_relobj<32, true>::do_scan_relocs(Symbol_table* symtab, template void Sized_relobj<64, false>::do_scan_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1475,7 +1475,7 @@ Sized_relobj<64, false>::do_scan_relocs(Symbol_table* symtab, template void Sized_relobj<64, true>::do_scan_relocs(Symbol_table* symtab, - Layout* alayout, + Layout* layout, Read_relocs_data* rd); #endif @@ -1483,7 +1483,7 @@ Sized_relobj<64, true>::do_scan_relocs(Symbol_table* symtab, template void Sized_relobj<32, false>::do_relocate(const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, Output_file* of); #endif @@ -1491,7 +1491,7 @@ Sized_relobj<32, false>::do_relocate(const Symbol_table* symtab, template void Sized_relobj<32, true>::do_relocate(const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, Output_file* of); #endif @@ -1499,7 +1499,7 @@ Sized_relobj<32, true>::do_relocate(const Symbol_table* symtab, template void Sized_relobj<64, false>::do_relocate(const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, Output_file* of); #endif @@ -1507,7 +1507,7 @@ Sized_relobj<64, false>::do_relocate(const Symbol_table* symtab, template void Sized_relobj<64, true>::do_relocate(const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, Output_file* of); #endif @@ -1516,7 +1516,7 @@ template void Sized_relobj<32, false>::do_relocate_sections( const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, const unsigned char* pshdrs, Views* pviews); #endif @@ -1526,7 +1526,7 @@ template void Sized_relobj<32, true>::do_relocate_sections( const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, const unsigned char* pshdrs, Views* pviews); #endif @@ -1536,7 +1536,7 @@ template void Sized_relobj<64, false>::do_relocate_sections( const Symbol_table* symtab, - const Layout* alayout, + const Layout* layout, const unsigned char* pshdrs, Views* pviews); #endif diff --git a/gold/reloc.h b/gold/reloc.h index 30a55ff..5dd4c85 100644 --- a/gold/reloc.h +++ b/gold/reloc.h @@ -259,10 +259,10 @@ class Relocatable_relocs // Record what to do for the next reloc. void - set_next_reloc_strategy(Reloc_strategy astrategy) + set_next_reloc_strategy(Reloc_strategy strategy) { - this->reloc_strategies_.push_back(static_cast<unsigned char>(astrategy)); - if (astrategy != RELOC_DISCARD) + this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy)); + if (strategy != RELOC_DISCARD) ++this->output_reloc_count_; } diff --git a/gold/resolve.cc b/gold/resolve.cc index 1d77a92..89b10b9 100644 --- a/gold/resolve.cc +++ b/gold/resolve.cc @@ -37,9 +37,9 @@ namespace gold // VERSION. Update the VERSION_ field accordingly. inline void -Symbol::override_version(const char* aversion) +Symbol::override_version(const char* version) { - if (aversion == NULL) + if (version == NULL) { // This is the case where this symbol is NAME/VERSION, and the // version was not marked as hidden. That makes it the default @@ -49,7 +49,7 @@ Symbol::override_version(const char* aversion) // override NAME/VERSION as well. They are already the same // Symbol structure. Setting the VERSION_ field to NULL ensures // that it will be output with the correct, empty, version. - this->version_ = aversion; + this->version_ = version; } else { @@ -58,8 +58,8 @@ Symbol::override_version(const char* aversion) // overriding NAME. If VERSION_ONE and VERSION_TWO are // different, then this can only happen when VERSION_ONE is NULL // and VERSION_TWO is not hidden. - gold_assert(this->version_ == aversion || this->version_ == NULL); - this->version_ = aversion; + gold_assert(this->version_ == version || this->version_ == NULL); + this->version_ = version; } } @@ -67,19 +67,19 @@ Symbol::override_version(const char* aversion) // is VISIBILITY. Updated the VISIBILITY_ field accordingly. inline void -Symbol::override_visibility(elfcpp::STV avisibility) +Symbol::override_visibility(elfcpp::STV visibility) { // The rule for combining visibility is that we always choose the // most constrained visibility. In order of increasing constraint, // visibility goes PROTECTED, HIDDEN, INTERNAL. This is the reverse // of the numeric values, so the effect is that we always want the // smallest non-zero value. - if (avisibility != elfcpp::STV_DEFAULT) + if (visibility != elfcpp::STV_DEFAULT) { if (this->visibility_ == elfcpp::STV_DEFAULT) - this->visibility_ = avisibility; - else if (this->visibility_ > avisibility) - this->visibility_ = avisibility; + this->visibility_ = visibility; + else if (this->visibility_ > visibility) + this->visibility_ = visibility; } } @@ -89,18 +89,18 @@ template<int size, bool big_endian> void Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym, unsigned int st_shndx, bool is_ordinary, - Object* aobject, const char* aversion) + Object* object, const char* version) { gold_assert(this->source_ == FROM_OBJECT); - this->u_.from_object.object = aobject; - this->override_version(aversion); + this->u_.from_object.object = object; + this->override_version(version); this->u_.from_object.shndx = st_shndx; this->is_ordinary_shndx_ = is_ordinary; this->type_ = sym.get_st_type(); this->binding_ = sym.get_st_bind(); this->override_visibility(sym.get_st_visibility()); this->nonvis_ = sym.get_st_nonvis(); - if (aobject->is_dynamic()) + if (object->is_dynamic()) this->in_dyn_ = true; else this->in_reg_ = true; @@ -113,9 +113,9 @@ template<bool big_endian> void Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym, unsigned st_shndx, bool is_ordinary, - Object* aobject, const char* aversion) + Object* object, const char* version) { - this->override_base(sym, st_shndx, is_ordinary, aobject, aversion); + this->override_base(sym, st_shndx, is_ordinary, object, version); this->value_ = sym.get_st_value(); this->symsize_ = sym.get_st_size(); } @@ -128,9 +128,9 @@ void Symbol_table::override(Sized_symbol<size>* tosym, const elfcpp::Sym<size, big_endian>& fromsym, unsigned int st_shndx, bool is_ordinary, - Object* aobject, const char* aversion) + Object* object, const char* version) { - tosym->override(fromsym, st_shndx, is_ordinary, aobject, aversion); + tosym->override(fromsym, st_shndx, is_ordinary, object, version); if (tosym->has_alias()) { Symbol* sym = this->weak_aliases_[tosym]; @@ -138,7 +138,7 @@ Symbol_table::override(Sized_symbol<size>* tosym, Sized_symbol<size>* ssym = this->get_sized_symbol<size>(sym); do { - ssym->override(fromsym, st_shndx, is_ordinary, aobject, aversion); + ssym->override(fromsym, st_shndx, is_ordinary, object, version); sym = this->weak_aliases_[ssym]; gold_assert(sym != NULL); ssym = this->get_sized_symbol<size>(sym); diff --git a/gold/script-sections.cc b/gold/script-sections.cc index b8e1cef..f38cbd0 100644 --- a/gold/script-sections.cc +++ b/gold/script-sections.cc @@ -1171,8 +1171,8 @@ Output_section_element_input::match_name(const char* file_name, class Input_section_info { public: - Input_section_info(const Output_section::Simple_input_section& inputsection) - : input_section_(inputsection), section_name_(), + Input_section_info(const Output_section::Simple_input_section& input_section) + : input_section_(input_section), section_name_(), size_(0), addralign_(1) { } @@ -1198,8 +1198,8 @@ class Input_section_info // Set the section name. void - set_section_name(const std::string aname) - { this->section_name_ = aname; } + set_section_name(const std::string name) + { this->section_name_ = name; } // Return the section size. uint64_t @@ -1208,8 +1208,8 @@ class Input_section_info // Set the section size. void - set_size(uint64_t sec_size) - { this->size_ = sec_size; } + set_size(uint64_t size) + { this->size_ = size; } // Return the address alignment. uint64_t @@ -1218,8 +1218,8 @@ class Input_section_info // Set the address alignment. void - set_addralign(uint64_t addr_align) - { this->addralign_ = addr_align; } + set_addralign(uint64_t addralign) + { this->addralign_ = addralign; } private: // Input section, can be a relaxed section. @@ -1388,12 +1388,12 @@ Output_section_element_input::set_section_addresses( Input_section_sorter(this->filename_sort_, isp.sort)); - for (std::vector<Input_section_info>::const_iterator q = + for (std::vector<Input_section_info>::const_iterator p = matching_sections[i].begin(); - q != matching_sections[i].end(); - ++q) + p != matching_sections[i].end(); + ++p) { - uint64_t this_subalign = q->addralign(); + uint64_t this_subalign = p->addralign(); if (this_subalign < subalign) this_subalign = subalign; @@ -1409,11 +1409,11 @@ Output_section_element_input::set_section_addresses( layout->new_output_section_data_from_script(posd); } - output_section->add_input_section_for_script(q->input_section(), - q->size(), + output_section->add_input_section_for_script(p->input_section(), + p->size(), this_subalign); - dot = address + q->size(); + dot = address + p->size(); } } @@ -2127,7 +2127,7 @@ bool Output_section_definition::get_output_section_info(const char* name, uint64_t* address, uint64_t* load_address, - uint64_t* addr_align, + uint64_t* addralign, uint64_t* size) const { if (this->name_ != name) @@ -2140,14 +2140,14 @@ Output_section_definition::get_output_section_info(const char* name, *load_address = this->output_section_->load_address(); else *load_address = *address; - *addr_align = this->output_section_->addralign(); + *addralign = this->output_section_->addralign(); *size = this->output_section_->current_data_size(); } else { *address = this->evaluated_address_; *load_address = this->evaluated_load_address_; - *addr_align = this->evaluated_addralign_; + *addralign = this->evaluated_addralign_; *size = 0; } @@ -2297,7 +2297,7 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, p != input_sections.end(); ++p) { - uint64_t addr_align; + uint64_t addralign; uint64_t size; // We know what are single-threaded, so it is OK to lock the @@ -2305,7 +2305,7 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, { const Task* task = reinterpret_cast<const Task*>(-1); Task_lock_obj<Object> tl(task, p->relobj()); - addr_align = p->relobj()->section_addralign(p->shndx()); + addralign = p->relobj()->section_addralign(p->shndx()); if (p->is_relaxed_input_section()) // We use current data size because relxed section sizes may not // have finalized yet. @@ -2314,8 +2314,8 @@ Orphan_output_section::set_section_addresses(Symbol_table*, Layout*, size = p->relobj()->section_size(p->shndx()); } - address = align_address(address, addr_align); - this->os_->add_input_section_for_script(*p, size, addr_align); + address = align_address(address, addralign); + this->os_->add_input_section_for_script(*p, size, addralign); address += size; } @@ -2351,13 +2351,13 @@ Orphan_output_section::allocate_to_segment(String_list**, bool* orphan) class Phdrs_element { public: - Phdrs_element(const char* aname, size_t namelen, unsigned int atype, - bool include_filehdr, bool include_phdrs, + Phdrs_element(const char* name, size_t namelen, unsigned int type, + bool includes_filehdr, bool includes_phdrs, bool is_flags_valid, unsigned int flags, - Expression* aload_address) - : name_(aname, namelen), type_(atype), includes_filehdr_(include_filehdr), - includes_phdrs_(include_phdrs), is_flags_valid_(is_flags_valid), - flags_(flags), load_address_(aload_address), load_address_value_(0), + Expression* load_address) + : name_(name, namelen), type_(type), includes_filehdr_(includes_filehdr), + includes_phdrs_(includes_phdrs), is_flags_valid_(is_flags_valid), + flags_(flags), load_address_(load_address), load_address_value_(0), segment_(NULL) { } @@ -2388,10 +2388,10 @@ class Phdrs_element // Evaluate the load address expression if there is one. void - eval_load_address(Symbol_table* symtab, Layout* alayout) + eval_load_address(Symbol_table* symtab, Layout* layout) { if (this->load_address_ != NULL) - this->load_address_value_ = this->load_address_->eval(symtab, alayout, + this->load_address_value_ = this->load_address_->eval(symtab, layout, true); } @@ -3496,7 +3496,7 @@ Script_sections::put_headers_in_phdrs(Output_data* file_header, bool Script_sections::get_output_section_info(const char* name, uint64_t* address, uint64_t* load_address, - uint64_t* addr_align, + uint64_t* addralign, uint64_t* size) const { if (!this->saw_sections_clause_) @@ -3504,7 +3504,7 @@ Script_sections::get_output_section_info(const char* name, uint64_t* address, for (Sections_elements::const_iterator p = this->sections_elements_->begin(); p != this->sections_elements_->end(); ++p) - if ((*p)->get_output_section_info(name, address, load_address, addr_align, + if ((*p)->get_output_section_info(name, address, load_address, addralign, size)) return true; return false; diff --git a/gold/script.cc b/gold/script.cc index ec7ce07..8839213 100644 --- a/gold/script.cc +++ b/gold/script.cc @@ -78,28 +78,28 @@ class Token { } // A general token with no value. - Token(Classification aclassification, int linenum, int char_pos) - : classification_(aclassification), value_(NULL), value_length_(0), - opcode_(0), lineno_(linenum), charpos_(char_pos) + Token(Classification classification, int lineno, int charpos) + : classification_(classification), value_(NULL), value_length_(0), + opcode_(0), lineno_(lineno), charpos_(charpos) { - gold_assert(aclassification == TOKEN_INVALID - || aclassification == TOKEN_EOF); + gold_assert(classification == TOKEN_INVALID + || classification == TOKEN_EOF); } // A general token with a value. - Token(Classification aclassification, const char* value, size_t length, - int linenum, int char_pos) - : classification_(aclassification), value_(value), value_length_(length), - opcode_(0), lineno_(linenum), charpos_(char_pos) + Token(Classification classification, const char* value, size_t length, + int lineno, int charpos) + : classification_(classification), value_(value), value_length_(length), + opcode_(0), lineno_(lineno), charpos_(charpos) { - gold_assert(aclassification != TOKEN_INVALID - && aclassification != TOKEN_EOF); + gold_assert(classification != TOKEN_INVALID + && classification != TOKEN_EOF); } // A token representing an operator. - Token(int opcode, int linenum, int char_pos) + Token(int opcode, int lineno, int charpos) : classification_(TOKEN_OPERATOR), value_(NULL), value_length_(0), - opcode_(opcode), lineno_(linenum), charpos_(char_pos) + opcode_(opcode), lineno_(lineno), charpos_(charpos) { } // Return whether the token is invalid. @@ -213,8 +213,8 @@ class Lex // Set the lexing mode. void - set_mode(Mode mde) - { this->mode_ = mde; } + set_mode(Mode mode) + { this->mode_ = mode; } private: Lex(const Lex&); @@ -1160,19 +1160,19 @@ Script_options::set_section_addresses(Symbol_table* symtab, Layout* layout) class Parser_closure { public: - Parser_closure(const char* afilename, + Parser_closure(const char* filename, const Position_dependent_options& posdep_options, - bool in_a_group, bool is_in_a_sysroot, - Command_line* acommand_line, - Script_options* script_opts, + bool in_group, bool is_in_sysroot, + Command_line* command_line, + Script_options* script_options, Lex* lex, - bool skip_on_a_incompatible_target) - : filename_(afilename), posdep_options_(posdep_options), - in_group_(in_a_group), is_in_sysroot_(is_in_a_sysroot), - skip_on_incompatible_target_(skip_on_a_incompatible_target), + bool skip_on_incompatible_target) + : filename_(filename), posdep_options_(posdep_options), + in_group_(in_group), is_in_sysroot_(is_in_sysroot), + skip_on_incompatible_target_(skip_on_incompatible_target), found_incompatible_target_(false), - command_line_(acommand_line), script_options_(script_opts), - version_script_info_(script_opts->version_script_info()), + command_line_(command_line), script_options_(script_options), + version_script_info_(script_options->version_script_info()), lex_(lex), lineno_(0), charpos_(0), lex_mode_stack_(), inputs_(NULL) { // We start out processing C symbols in the default lex mode. @@ -1814,10 +1814,10 @@ Lazy_demangler::get() // For example, pattern="std::map*" and language="C++". // pattern and language should be from the stringpool struct Version_expression { - Version_expression(const std::string& apattern, - const std::string& alanguage, - bool is_exact_match) - : pattern(apattern), language(alanguage), exact_match(is_exact_match) {} + Version_expression(const std::string& pattern, + const std::string& language, + bool exact_match) + : pattern(pattern), language(language), exact_match(exact_match) {} std::string pattern; std::string language; diff --git a/gold/script.h b/gold/script.h index 1afe44d..755bb79 100644 --- a/gold/script.h +++ b/gold/script.h @@ -261,9 +261,9 @@ class Symbol_assignment class Script_assertion { public: - Script_assertion(Expression* echeck, const char* message, + Script_assertion(Expression* check, const char* message, size_t messagelen) - : check_(echeck), message_(message, messagelen) + : check_(check), message_(message, messagelen) { } // Check the assertion. @@ -390,8 +390,8 @@ class Script_options class Script_info { public: - Script_info(Input_arguments* arg_inputs) - : inputs_(arg_inputs) + Script_info(Input_arguments* inputs) + : inputs_(inputs) { } // Returns the input files included because of this script. diff --git a/gold/sparc.cc b/gold/sparc.cc index 43c6e34..8047a11 100644 --- a/gold/sparc.cc +++ b/gold/sparc.cc @@ -401,13 +401,13 @@ private: rela(unsigned char* view, unsigned int right_shift, typename elfcpp::Elf_types<valsize>::Elf_Addr dst_mask, - typename elfcpp::Swap<size, big_endian>::Valtype avalue, + typename elfcpp::Swap<size, big_endian>::Valtype value, typename elfcpp::Swap<size, big_endian>::Valtype addend) { typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); Valtype val = elfcpp::Swap<valsize, big_endian>::readval(wv); - Valtype reloc = ((avalue + addend) >> right_shift); + Valtype reloc = ((value + addend) >> right_shift); val &= ~dst_mask; reloc &= dst_mask; @@ -589,10 +589,10 @@ public: // R_SPARC_HI22: (Symbol + Addend) >> 10 static inline void hi22(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { - This_insn::template rela<32>(view, 10, 0x003fffff, avalue, addend); + This_insn::template rela<32>(view, 10, 0x003fffff, value, addend); } // R_SPARC_HI22: (Symbol + Addend) >> 10 @@ -620,10 +620,10 @@ public: // R_SPARC_LO10: (Symbol + Addend) & 0x3ff static inline void lo10(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { - This_insn::template rela<32>(view, 0, 0x000003ff, avalue, addend); + This_insn::template rela<32>(view, 0, 0x000003ff, value, addend); } // R_SPARC_LO10: (Symbol + Addend) & 0x3ff @@ -682,10 +682,10 @@ public: // R_SPARC_13: (Symbol + Addend) static inline void rela32_13(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { - This_insn::template rela<32>(view, 0, 0x00001fff, avalue, addend); + This_insn::template rela<32>(view, 0, 0x00001fff, value, addend); } // R_SPARC_13: (Symbol + Addend) @@ -904,22 +904,22 @@ public: // R_SPARC_TLS_LDO_HIX22: @dtpoff(Symbol + Addend) >> 10 static inline void ldo_hix22(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { - This_insn::hi22(view, avalue, addend); + This_insn::hi22(view, value, addend); } // R_SPARC_TLS_LDO_LOX10: @dtpoff(Symbol + Addend) & 0x3ff static inline void ldo_lox10(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { typedef typename elfcpp::Swap<32, true>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); Valtype val = elfcpp::Swap<32, true>::readval(wv); - Valtype reloc = (avalue + addend); + Valtype reloc = (value + addend); val &= ~0x1fff; reloc &= 0x3ff; @@ -930,13 +930,13 @@ public: // R_SPARC_TLS_LE_HIX22: (@tpoff(Symbol + Addend) ^ 0xffffffffffffffff) >> 10 static inline void hix22(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { typedef typename elfcpp::Swap<32, true>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); Valtype val = elfcpp::Swap<32, true>::readval(wv); - Valtype reloc = (avalue + addend); + Valtype reloc = (value + addend); val &= ~0x3fffff; @@ -974,13 +974,13 @@ public: // R_SPARC_TLS_LE_LOX10: (@tpoff(Symbol + Addend) & 0x3ff) | 0x1c00 static inline void lox10(unsigned char* view, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, + typename elfcpp::Elf_types<size>::Elf_Addr value, typename elfcpp::Elf_types<size>::Elf_Addr addend) { typedef typename elfcpp::Swap<32, true>::Valtype Valtype; Valtype* wv = reinterpret_cast<Valtype*>(view); Valtype val = elfcpp::Swap<32, true>::readval(wv); - Valtype reloc = (avalue + addend); + Valtype reloc = (value + addend); val &= ~0x1fff; reloc &= 0x3ff; @@ -1220,10 +1220,10 @@ template<int size, bool big_endian> void Output_data_plt_sparc<size, big_endian>::do_write(Output_file* of) { - const off_t off = this->offset(); + const off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); unsigned char* pov = oview; memset(pov, 0, base_plt_entry_size * 4); @@ -1347,7 +1347,7 @@ Output_data_plt_sparc<size, big_endian>::do_write(Output_file* of) gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); } // Create a PLT entry for a global symbol. @@ -2260,9 +2260,9 @@ Target_sparc<size, big_endian>::gc_process_relocs( const unsigned char* plocal_symbols) { typedef Target_sparc<size, big_endian> Sparc; - typedef typename Target_sparc<size, big_endian>::Scan scan; + typedef typename Target_sparc<size, big_endian>::Scan Scan; - gold::gc_process_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, scan>( + gold::gc_process_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>( symtab, layout, this, @@ -2294,7 +2294,7 @@ Target_sparc<size, big_endian>::scan_relocs( const unsigned char* plocal_symbols) { typedef Target_sparc<size, big_endian> Sparc; - typedef typename Target_sparc<size, big_endian>::Scan scan; + typedef typename Target_sparc<size, big_endian>::Scan Scan; if (sh_type == elfcpp::SHT_REL) { @@ -2303,7 +2303,7 @@ Target_sparc<size, big_endian>::scan_relocs( return; } - gold::scan_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, scan>( + gold::scan_relocs<size, big_endian, Sparc, elfcpp::SHT_RELA, Scan>( symtab, layout, this, @@ -2415,11 +2415,11 @@ Target_sparc<size, big_endian>::Relocate::relocate( || r_type == elfcpp::R_SPARC_WDISP19 || r_type == elfcpp::R_SPARC_WDISP16)) { - elfcpp::Elf_Xword avalue; + elfcpp::Elf_Xword value; - avalue = target->plt_section()->address() + gsym->plt_offset(); + value = target->plt_section()->address() + gsym->plt_offset(); - symval.set_output_value(avalue); + symval.set_output_value(value); psymval = &symval; } @@ -2740,7 +2740,7 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( typedef typename elfcpp::Swap<32, true>::Valtype Insntype; const elfcpp::Elf_Xword addend = rela.get_r_addend(); - typename elfcpp::Elf_types<size>::Elf_Addr avalue = psymval->value(object, 0); + typename elfcpp::Elf_types<size>::Elf_Addr value = psymval->value(object, 0); const bool is_final = (gsym == NULL @@ -2760,18 +2760,18 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( Insntype* wv = reinterpret_cast<Insntype*>(view); Insntype val; - avalue -= tls_segment->memsz(); + value -= tls_segment->memsz(); switch (r_type) { case elfcpp::R_SPARC_TLS_GD_HI22: // TLS_GD_HI22 --> TLS_LE_HIX22 - Reloc::hix22(view, avalue, addend); + Reloc::hix22(view, value, addend); break; case elfcpp::R_SPARC_TLS_GD_LO10: // TLS_GD_LO10 --> TLS_LE_LOX10 - Reloc::lox10(view, avalue, addend); + Reloc::lox10(view, value, addend); break; case elfcpp::R_SPARC_TLS_GD_ADD: @@ -2795,13 +2795,13 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( if (gsym != NULL) { gold_assert(gsym->has_got_offset(got_type)); - avalue = gsym->got_offset(got_type); + value = gsym->got_offset(got_type); } else { unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); gold_assert(object->local_has_got_offset(r_sym, got_type)); - avalue = object->local_got_offset(r_sym, got_type); + value = object->local_got_offset(r_sym, got_type); } if (optimized_type == tls::TLSOPT_TO_IE) { @@ -2812,12 +2812,12 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( { case elfcpp::R_SPARC_TLS_GD_HI22: // TLS_GD_HI22 --> TLS_IE_HI22 - Reloc::hi22(view, avalue, addend); + Reloc::hi22(view, value, addend); break; case elfcpp::R_SPARC_TLS_GD_LO10: // TLS_GD_LO10 --> TLS_IE_LO10 - Reloc::lo10(view, avalue, addend); + Reloc::lo10(view, value, addend); break; case elfcpp::R_SPARC_TLS_GD_ADD: @@ -2867,24 +2867,24 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( switch (r_type) { case elfcpp::R_SPARC_TLS_GD_HI22: - Reloc::hi22(view, avalue, addend); + Reloc::hi22(view, value, addend); break; case elfcpp::R_SPARC_TLS_GD_LO10: - Reloc::lo10(view, avalue, addend); + Reloc::lo10(view, value, addend); break; case elfcpp::R_SPARC_TLS_GD_ADD: break; case elfcpp::R_SPARC_TLS_GD_CALL: { Symbol_value<size> symval; - elfcpp::Elf_Xword xvalue; + elfcpp::Elf_Xword value; Symbol* tsym; tsym = target->tls_get_addr_sym_; gold_assert(tsym); - xvalue = (target->plt_section()->address() + - tsym->plt_offset()); - symval.set_output_value(xvalue); + value = (target->plt_section()->address() + + tsym->plt_offset()); + symval.set_output_value(value); Reloc::wdisp30(view, object, &symval, addend, address); } break; @@ -2939,14 +2939,14 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( case elfcpp::R_SPARC_TLS_LDM_CALL: { Symbol_value<size> symval; - elfcpp::Elf_Xword xvalue; + elfcpp::Elf_Xword value; Symbol* tsym; tsym = target->tls_get_addr_sym_; gold_assert(tsym); - xvalue = (target->plt_section()->address() + - tsym->plt_offset()); - symval.set_output_value(xvalue); + value = (target->plt_section()->address() + + tsym->plt_offset()); + symval.set_output_value(value); Reloc::wdisp30(view, object, &symval, addend, address); } break; @@ -2964,20 +2964,20 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( case elfcpp::R_SPARC_TLS_LDO_HIX22: if (optimized_type == tls::TLSOPT_TO_LE) { - avalue -= tls_segment->memsz(); - Reloc::hix22(view, avalue, addend); + value -= tls_segment->memsz(); + Reloc::hix22(view, value, addend); } else - Reloc::ldo_hix22(view, avalue, addend); + Reloc::ldo_hix22(view, value, addend); break; case elfcpp::R_SPARC_TLS_LDO_LOX10: if (optimized_type == tls::TLSOPT_TO_LE) { - avalue -= tls_segment->memsz(); - Reloc::lox10(view, avalue, addend); + value -= tls_segment->memsz(); + Reloc::lox10(view, value, addend); } else - Reloc::ldo_lox10(view, avalue, addend); + Reloc::ldo_lox10(view, value, addend); break; case elfcpp::R_SPARC_TLS_LDO_ADD: if (optimized_type == tls::TLSOPT_TO_LE) @@ -3018,16 +3018,16 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( case elfcpp::R_SPARC_TLS_IE_LO10: if (optimized_type == tls::TLSOPT_TO_LE) { - avalue -= tls_segment->memsz(); + value -= tls_segment->memsz(); switch (r_type) { case elfcpp::R_SPARC_TLS_IE_HI22: // IE_HI22 --> LE_HIX22 - Reloc::hix22(view, avalue, addend); + Reloc::hix22(view, value, addend); break; case elfcpp::R_SPARC_TLS_IE_LO10: // IE_LO10 --> LE_LOX10 - Reloc::lox10(view, avalue, addend); + Reloc::lox10(view, value, addend); break; } break; @@ -3039,23 +3039,23 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( if (gsym != NULL) { gold_assert(gsym->has_got_offset(GOT_TYPE_TLS_OFFSET)); - avalue = gsym->got_offset(GOT_TYPE_TLS_OFFSET); + value = gsym->got_offset(GOT_TYPE_TLS_OFFSET); } else { unsigned int r_sym = elfcpp::elf_r_sym<size>(rela.get_r_info()); gold_assert(object->local_has_got_offset(r_sym, GOT_TYPE_TLS_OFFSET)); - avalue = object->local_got_offset(r_sym, - GOT_TYPE_TLS_OFFSET); + value = object->local_got_offset(r_sym, + GOT_TYPE_TLS_OFFSET); } switch (r_type) { case elfcpp::R_SPARC_TLS_IE_HI22: - Reloc::hi22(view, avalue, addend); + Reloc::hi22(view, value, addend); break; case elfcpp::R_SPARC_TLS_IE_LO10: - Reloc::lo10(view, avalue, addend); + Reloc::lo10(view, value, addend); break; } break; @@ -3076,8 +3076,8 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( // have been created for this location, so do not apply it now. if (!parameters->options().shared()) { - avalue -= tls_segment->memsz(); - Reloc::hix22(view, avalue, addend); + value -= tls_segment->memsz(); + Reloc::hix22(view, value, addend); } break; @@ -3086,8 +3086,8 @@ Target_sparc<size, big_endian>::Relocate::relocate_tls( // have been created for this location, so do not apply it now. if (!parameters->options().shared()) { - avalue -= tls_segment->memsz(); - Reloc::lox10(view, avalue, addend); + value -= tls_segment->memsz(); + Reloc::lox10(view, value, addend); } break; } @@ -3238,18 +3238,18 @@ public: (size == 64 ? "elf64-sparc" : "elf32-sparc")) { } - Target* do_recognize(int amachine, int, int) + Target* do_recognize(int machine, int, int) { switch (size) { case 64: - if (amachine != elfcpp::EM_SPARCV9) + if (machine != elfcpp::EM_SPARCV9) return NULL; break; case 32: - if (amachine != elfcpp::EM_SPARC - && amachine != elfcpp::EM_SPARC32PLUS) + if (machine != elfcpp::EM_SPARC + && machine != elfcpp::EM_SPARC32PLUS) return NULL; break; diff --git a/gold/symtab.cc b/gold/symtab.cc index 30ed8f7..7e8a890 100644 --- a/gold/symtab.cc +++ b/gold/symtab.cc @@ -50,20 +50,20 @@ namespace gold // and source_. void -Symbol::init_fields(const char* aname, const char* aversion, - elfcpp::STT atype, elfcpp::STB abinding, - elfcpp::STV avisibility, unsigned char non_vis) +Symbol::init_fields(const char* name, const char* version, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) { - this->name_ = aname; - this->version_ = aversion; + this->name_ = name; + this->version_ = version; this->symtab_index_ = 0; this->dynsym_index_ = 0; this->got_offsets_.init(); this->plt_offset_ = 0; - this->type_ = atype; - this->binding_ = abinding; - this->visibility_ = avisibility; - this->nonvis_ = non_vis; + this->type_ = type; + this->binding_ = binding; + this->visibility_ = visibility; + this->nonvis_ = nonvis; this->is_target_special_ = false; this->is_def_ = false; this->is_forwarder_ = false; @@ -83,16 +83,16 @@ Symbol::init_fields(const char* aname, const char* aversion, // if the --demangle flag was set. static std::string -demangle(const char* aname) +demangle(const char* name) { if (!parameters->options().do_demangle()) - return aname; + return name; // cplus_demangle allocates memory for the result it returns, // and returns NULL if the name is already demangled. - char* demangled_name = cplus_demangle(aname, DMGL_ANSI | DMGL_PARAMS); + char* demangled_name = cplus_demangle(name, DMGL_ANSI | DMGL_PARAMS); if (demangled_name == NULL) - return aname; + return name; std::string retval(demangled_name); free(demangled_name); @@ -109,33 +109,33 @@ Symbol::demangled_name() const template<int size, bool big_endian> void -Symbol::init_base_object(const char* aname, const char* aversion, Object* aobject, +Symbol::init_base_object(const char* name, const char* version, Object* object, const elfcpp::Sym<size, big_endian>& sym, unsigned int st_shndx, bool is_ordinary) { - this->init_fields(aname, aversion, sym.get_st_type(), sym.get_st_bind(), + this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(), sym.get_st_visibility(), sym.get_st_nonvis()); - this->u_.from_object.object = aobject; + this->u_.from_object.object = object; this->u_.from_object.shndx = st_shndx; this->is_ordinary_shndx_ = is_ordinary; this->source_ = FROM_OBJECT; - this->in_reg_ = !aobject->is_dynamic(); - this->in_dyn_ = aobject->is_dynamic(); - this->in_real_elf_ = aobject->pluginobj() == NULL; + this->in_reg_ = !object->is_dynamic(); + this->in_dyn_ = object->is_dynamic(); + this->in_real_elf_ = object->pluginobj() == NULL; } // Initialize the fields in the base class Symbol for a symbol defined // in an Output_data. void -Symbol::init_base_output_data(const char* aname, const char* aversion, - Output_data* od, elfcpp::STT atype, - elfcpp::STB abinding, elfcpp::STV avisibility, - unsigned char non_vis, bool offset_is_from_the_end) +Symbol::init_base_output_data(const char* name, const char* version, + Output_data* od, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis, bool offset_is_from_end) { - this->init_fields(aname, aversion, atype, abinding, avisibility, non_vis); + this->init_fields(name, version, type, binding, visibility, nonvis); this->u_.in_output_data.output_data = od; - this->u_.in_output_data.offset_is_from_end = offset_is_from_the_end; + this->u_.in_output_data.offset_is_from_end = offset_is_from_end; this->source_ = IN_OUTPUT_DATA; this->in_reg_ = true; this->in_real_elf_ = true; @@ -145,15 +145,15 @@ Symbol::init_base_output_data(const char* aname, const char* aversion, // in an Output_segment. void -Symbol::init_base_output_segment(const char* aname, const char* aversion, - Output_segment* os, elfcpp::STT atype, - elfcpp::STB abinding, elfcpp::STV avisibility, - unsigned char non_vis, - Segment_offset_base offsetbase) +Symbol::init_base_output_segment(const char* name, const char* version, + Output_segment* os, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis, + Segment_offset_base offset_base) { - this->init_fields(aname, aversion, atype, abinding, avisibility, non_vis); + this->init_fields(name, version, type, binding, visibility, nonvis); this->u_.in_output_segment.output_segment = os; - this->u_.in_output_segment.offset_base = offsetbase; + this->u_.in_output_segment.offset_base = offset_base; this->source_ = IN_OUTPUT_SEGMENT; this->in_reg_ = true; this->in_real_elf_ = true; @@ -163,11 +163,11 @@ Symbol::init_base_output_segment(const char* aname, const char* aversion, // as a constant. void -Symbol::init_base_constant(const char* aname, const char* aversion, - elfcpp::STT atype, elfcpp::STB abinding, - elfcpp::STV avisibility, unsigned char non_vis) +Symbol::init_base_constant(const char* name, const char* version, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) { - this->init_fields(aname, aversion, atype, abinding, avisibility, non_vis); + this->init_fields(name, version, type, binding, visibility, nonvis); this->source_ = IS_CONSTANT; this->in_reg_ = true; this->in_real_elf_ = true; @@ -177,11 +177,11 @@ Symbol::init_base_constant(const char* aname, const char* aversion, // symbol. void -Symbol::init_base_undefined(const char* aname, const char* aversion, - elfcpp::STT atype, elfcpp::STB abinding, - elfcpp::STV avisibility, unsigned char non_vis) +Symbol::init_base_undefined(const char* name, const char* version, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) { - this->init_fields(aname, aversion, atype, abinding, avisibility, non_vis); + this->init_fields(name, version, type, binding, visibility, nonvis); this->dynsym_index_ = -1U; this->source_ = IS_UNDEFINED; this->in_reg_ = true; @@ -204,12 +204,12 @@ Symbol::allocate_base_common(Output_data* od) template<int size> template<bool big_endian> void -Sized_symbol<size>::init_object(const char* aname, const char* aversion, - Object* aobject, +Sized_symbol<size>::init_object(const char* name, const char* version, + Object* object, const elfcpp::Sym<size, big_endian>& sym, unsigned int st_shndx, bool is_ordinary) { - this->init_base_object(aname, aversion, aobject, sym, st_shndx, is_ordinary); + this->init_base_object(name, version, object, sym, st_shndx, is_ordinary); this->value_ = sym.get_st_value(); this->symsize_ = sym.get_st_size(); } @@ -219,18 +219,18 @@ Sized_symbol<size>::init_object(const char* aname, const char* aversion, template<int size> void -Sized_symbol<size>::init_output_data(const char* aname, const char* aversion, - Output_data* od, Value_type avalue, - Size_type sym_size, elfcpp::STT atype, - elfcpp::STB abinding, - elfcpp::STV avisibility, - unsigned char non_vis, - bool offset_is_from_the_end) +Sized_symbol<size>::init_output_data(const char* name, const char* version, + Output_data* od, Value_type value, + Size_type symsize, elfcpp::STT type, + elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + bool offset_is_from_end) { - this->init_base_output_data(aname, aversion, od, atype, abinding, avisibility, - non_vis, offset_is_from_the_end); - this->value_ = avalue; - this->symsize_ = sym_size; + this->init_base_output_data(name, version, od, type, binding, visibility, + nonvis, offset_is_from_end); + this->value_ = value; + this->symsize_ = symsize; } // Initialize the fields in Sized_symbol for a symbol defined in an @@ -238,18 +238,18 @@ Sized_symbol<size>::init_output_data(const char* aname, const char* aversion, template<int size> void -Sized_symbol<size>::init_output_segment(const char* aname, const char* aversion, - Output_segment* os, Value_type avalue, - Size_type sym_size, elfcpp::STT atype, - elfcpp::STB abinding, - elfcpp::STV avisibility, - unsigned char non_vis, - Segment_offset_base offsetbase) +Sized_symbol<size>::init_output_segment(const char* name, const char* version, + Output_segment* os, Value_type value, + Size_type symsize, elfcpp::STT type, + elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + Segment_offset_base offset_base) { - this->init_base_output_segment(aname, aversion, os, atype, abinding, avisibility, - non_vis, offsetbase); - this->value_ = avalue; - this->symsize_ = sym_size; + this->init_base_output_segment(name, version, os, type, binding, visibility, + nonvis, offset_base); + this->value_ = value; + this->symsize_ = symsize; } // Initialize the fields in Sized_symbol for a symbol defined as a @@ -257,25 +257,25 @@ Sized_symbol<size>::init_output_segment(const char* aname, const char* aversion, template<int size> void -Sized_symbol<size>::init_constant(const char* aname, const char* aversion, - Value_type avalue, Size_type sym_size, - elfcpp::STT atype, elfcpp::STB abinding, - elfcpp::STV avisibility, unsigned char non_vis) +Sized_symbol<size>::init_constant(const char* name, const char* version, + Value_type value, Size_type symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) { - this->init_base_constant(aname, aversion, atype, abinding, avisibility, non_vis); - this->value_ = avalue; - this->symsize_ = sym_size; + this->init_base_constant(name, version, type, binding, visibility, nonvis); + this->value_ = value; + this->symsize_ = symsize; } // Initialize the fields in Sized_symbol for an undefined symbol. template<int size> void -Sized_symbol<size>::init_undefined(const char* aname, const char* aversion, - elfcpp::STT atype, elfcpp::STB abinding, - elfcpp::STV avisibility, unsigned char non_vis) +Sized_symbol<size>::init_undefined(const char* name, const char* version, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) { - this->init_base_undefined(aname, aversion, atype, abinding, avisibility, non_vis); + this->init_base_undefined(name, version, type, binding, visibility, nonvis); this->value_ = 0; this->symsize_ = 0; } @@ -283,21 +283,21 @@ Sized_symbol<size>::init_undefined(const char* aname, const char* aversion, // Return true if SHNDX represents a common symbol. bool -Symbol::is_common_shndx(unsigned int sec_shndx) +Symbol::is_common_shndx(unsigned int shndx) { - return (sec_shndx == elfcpp::SHN_COMMON - || sec_shndx == parameters->target().small_common_shndx() - || sec_shndx == parameters->target().large_common_shndx()); + return (shndx == elfcpp::SHN_COMMON + || shndx == parameters->target().small_common_shndx() + || shndx == parameters->target().large_common_shndx()); } // Allocate a common symbol. template<int size> void -Sized_symbol<size>::allocate_common(Output_data* od, Value_type avalue) +Sized_symbol<size>::allocate_common(Output_data* od, Value_type value) { this->allocate_base_common(od); - this->value_ = avalue; + this->value_ = value; } // The ""'s around str ensure str is a string literal, so sizeof works. @@ -323,9 +323,9 @@ Symbol::should_add_dynsym_entry() const { Relobj* relobj = static_cast<Relobj*>(this->object()); bool is_ordinary; - unsigned int sec_shndx = this->shndx(&is_ordinary); - if (is_ordinary && sec_shndx != elfcpp::SHN_UNDEF - && !relobj->is_section_included(sec_shndx)) + unsigned int shndx = this->shndx(&is_ordinary); + if (is_ordinary && shndx != elfcpp::SHN_UNDEF + && !relobj->is_section_included(shndx)) return false; } @@ -351,28 +351,28 @@ Symbol::should_add_dynsym_entry() const { // TODO(csilvers): We could probably figure out if we're an operator // new/delete or typeinfo without the need to demangle. - char* ademangled_name = cplus_demangle(this->name(), - DMGL_ANSI | DMGL_PARAMS); - if (ademangled_name == NULL) + char* demangled_name = cplus_demangle(this->name(), + DMGL_ANSI | DMGL_PARAMS); + if (demangled_name == NULL) { // Not a C++ symbol, so it can't satisfy these flags } else if (parameters->options().dynamic_list_cpp_new() - && (strprefix(ademangled_name, "operator new") - || strprefix(ademangled_name, "operator delete"))) + && (strprefix(demangled_name, "operator new") + || strprefix(demangled_name, "operator delete"))) { - free(ademangled_name); + free(demangled_name); return true; } else if (parameters->options().dynamic_list_cpp_typeinfo() - && (strprefix(ademangled_name, "typeinfo name for") - || strprefix(ademangled_name, "typeinfo for"))) + && (strprefix(demangled_name, "typeinfo name for") + || strprefix(demangled_name, "typeinfo for"))) { - free(ademangled_name); + free(demangled_name); return true; } else - free(ademangled_name); + free(demangled_name); } // If exporting all symbols or building a shared library, @@ -434,13 +434,13 @@ Symbol::output_section() const { case FROM_OBJECT: { - unsigned int sec_shndx = this->u_.from_object.shndx; - if (sec_shndx != elfcpp::SHN_UNDEF && this->is_ordinary_shndx_) + unsigned int shndx = this->u_.from_object.shndx; + if (shndx != elfcpp::SHN_UNDEF && this->is_ordinary_shndx_) { gold_assert(!this->u_.from_object.object->is_dynamic()); gold_assert(this->u_.from_object.object->pluginobj() == NULL); Relobj* relobj = static_cast<Relobj*>(this->u_.from_object.object); - return relobj->output_section(sec_shndx); + return relobj->output_section(shndx); } return NULL; } @@ -486,11 +486,11 @@ Symbol::set_output_section(Output_section* os) // Class Symbol_table. Symbol_table::Symbol_table(unsigned int count, - const Version_script_info& aversion_script) + const Version_script_info& version_script) : saw_undefined_(0), offset_(0), table_(count), namepool_(), forwarders_(), commons_(), tls_commons_(), small_commons_(), large_commons_(), forced_locals_(), warnings_(), - version_script_(aversion_script), gc_(NULL), icf_(NULL) + version_script_(version_script), gc_(NULL), icf_(NULL) { namepool_.reserve(count); } @@ -518,10 +518,10 @@ Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1, } bool -Symbol_table::is_section_folded(Object* obj, unsigned int sec_shndx) const +Symbol_table::is_section_folded(Object* obj, unsigned int shndx) const { return (parameters->options().icf_enabled() - && this->icf_->is_section_folded(obj, sec_shndx)); + && this->icf_->is_section_folded(obj, shndx)); } // For symbols that have been listed with -u option, add them to the @@ -535,19 +535,19 @@ Symbol_table::gc_mark_undef_symbols() p != parameters->options().undefined_end(); ++p) { - const char* aname = p->c_str(); - Symbol* sym = this->lookup(aname); + const char* name = p->c_str(); + Symbol* sym = this->lookup(name); gold_assert (sym != NULL); if (sym->source() == Symbol::FROM_OBJECT && !sym->object()->is_dynamic()) { Relobj* obj = static_cast<Relobj*>(sym->object()); bool is_ordinary; - unsigned int sec_shndx = sym->shndx(&is_ordinary); + unsigned int shndx = sym->shndx(&is_ordinary); if (is_ordinary) { gold_assert(this->gc_ != NULL); - this->gc_->worklist().push(Section_id(obj, sec_shndx)); + this->gc_->worklist().push(Section_id(obj, shndx)); } } } @@ -562,11 +562,11 @@ Symbol_table::gc_mark_symbol_for_shlib(Symbol* sym) //Add the object and section to the work list. Relobj* obj = static_cast<Relobj*>(sym->object()); bool is_ordinary; - unsigned int sec_shndx = sym->shndx(&is_ordinary); - if (is_ordinary && sec_shndx != elfcpp::SHN_UNDEF) + unsigned int shndx = sym->shndx(&is_ordinary); + if (is_ordinary && shndx != elfcpp::SHN_UNDEF) { gold_assert(this->gc_!= NULL); - this->gc_->worklist().push(Section_id(obj, sec_shndx)); + this->gc_->worklist().push(Section_id(obj, shndx)); } } } @@ -581,11 +581,11 @@ Symbol_table::gc_mark_dyn_syms(Symbol* sym) { Relobj *obj = static_cast<Relobj*>(sym->object()); bool is_ordinary; - unsigned int sec_shndx = sym->shndx(&is_ordinary); - if (is_ordinary && sec_shndx != elfcpp::SHN_UNDEF) + unsigned int shndx = sym->shndx(&is_ordinary); + if (is_ordinary && shndx != elfcpp::SHN_UNDEF) { gold_assert(this->gc_ != NULL); - this->gc_->worklist().push(Section_id(obj, sec_shndx)); + this->gc_->worklist().push(Section_id(obj, shndx)); } } } @@ -616,18 +616,18 @@ Symbol_table::resolve_forwards(const Symbol* from) const // Look up a symbol by name. Symbol* -Symbol_table::lookup(const char* aname, const char* aversion) const +Symbol_table::lookup(const char* name, const char* version) const { Stringpool::Key name_key; - aname = this->namepool_.find(aname, &name_key); - if (aname == NULL) + name = this->namepool_.find(name, &name_key); + if (name == NULL) return NULL; Stringpool::Key version_key = 0; - if (aversion != NULL) + if (version != NULL) { - aversion = this->namepool_.find(aversion, &version_key); - if (aversion == NULL) + version = this->namepool_.find(version, &version_key); + if (version == NULL) return NULL; } @@ -656,8 +656,8 @@ Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from) esym.put_st_info(from->binding(), from->type()); esym.put_st_other(from->visibility(), from->nonvis()); bool is_ordinary; - unsigned int sec_shndx = from->shndx(&is_ordinary); - this->resolve(to, esym.sym(), sec_shndx, is_ordinary, sec_shndx, from->object(), + unsigned int shndx = from->shndx(&is_ordinary); + this->resolve(to, esym.sym(), shndx, is_ordinary, shndx, from->object(), from->version()); if (from->in_reg()) to->set_in_reg(); @@ -689,25 +689,25 @@ Symbol_table::force_local(Symbol* sym) // option was used. const char* -Symbol_table::wrap_symbol(const char* aname, Stringpool::Key* name_key) +Symbol_table::wrap_symbol(const char* name, Stringpool::Key* name_key) { // For some targets, we need to ignore a specific character when // wrapping, and add it back later. char prefix = '\0'; - if (aname[0] == parameters->target().wrap_char()) + if (name[0] == parameters->target().wrap_char()) { - prefix = aname[0]; - ++aname; + prefix = name[0]; + ++name; } - if (parameters->options().is_wrap(aname)) + if (parameters->options().is_wrap(name)) { // Turn NAME into __wrap_NAME. std::string s; if (prefix != '\0') s += prefix; s += "__wrap_"; - s += aname; + s += name; // This will give us both the old and new name in NAMEPOOL_, but // that is OK. Only the versions we need will wind up in the @@ -717,18 +717,18 @@ Symbol_table::wrap_symbol(const char* aname, Stringpool::Key* name_key) const char* const real_prefix = "__real_"; const size_t real_prefix_length = strlen(real_prefix); - if (strncmp(aname, real_prefix, real_prefix_length) == 0 - && parameters->options().is_wrap(aname + real_prefix_length)) + if (strncmp(name, real_prefix, real_prefix_length) == 0 + && parameters->options().is_wrap(name + real_prefix_length)) { // Turn __real_NAME into NAME. std::string s; if (prefix != '\0') s += prefix; - s += aname + real_prefix_length; + s += name + real_prefix_length; return this->namepool_.add(s.c_str(), true, name_key); } - return aname; + return name; } // This is called when we see a symbol NAME/VERSION, and the symbol @@ -839,10 +839,10 @@ Symbol_table::define_default_version(Sized_symbol<size>* sym, template<int size, bool big_endian> Sized_symbol<size>* -Symbol_table::add_from_object(Object* aobject, - const char *aname, +Symbol_table::add_from_object(Object* object, + const char *name, Stringpool::Key name_key, - const char *aversion, + const char *version, Stringpool::Key version_key, bool def, const elfcpp::Sym<size, big_endian>& sym, @@ -851,12 +851,12 @@ Symbol_table::add_from_object(Object* aobject, unsigned int orig_st_shndx) { // Print a message if this symbol is being traced. - if (parameters->options().is_trace_symbol(aname)) + if (parameters->options().is_trace_symbol(name)) { if (orig_st_shndx == elfcpp::SHN_UNDEF) - gold_info(_("%s: reference to %s"), aobject->name().c_str(), aname); + gold_info(_("%s: reference to %s"), object->name().c_str(), name); else - gold_info(_("%s: definition of %s"), aobject->name().c_str(), aname); + gold_info(_("%s: definition of %s"), object->name().c_str(), name); } // For an undefined symbol, we may need to adjust the name using @@ -864,17 +864,17 @@ Symbol_table::add_from_object(Object* aobject, if (orig_st_shndx == elfcpp::SHN_UNDEF && parameters->options().any_wrap()) { - const char* wrap_name = this->wrap_symbol(aname, &name_key); - if (wrap_name != aname) + const char* wrap_name = this->wrap_symbol(name, &name_key); + if (wrap_name != name) { // If we see a reference to malloc with version GLIBC_2.0, // and we turn it into a reference to __wrap_malloc, then we // discard the version number. Otherwise the user would be // required to specify the correct version for // __wrap_malloc. - aversion = NULL; + version = NULL; version_key = 0; - aname = wrap_name; + name = wrap_name; } } @@ -910,8 +910,8 @@ Symbol_table::add_from_object(Object* aobject, was_undefined = ret->is_undefined(); was_common = ret->is_common(); - this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, aobject, - aversion); + this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object, + version); if (parameters->options().gc_sections()) this->gc_mark_dyn_syms(ret); @@ -933,8 +933,8 @@ Symbol_table::add_from_object(Object* aobject, was_undefined = ret->is_undefined(); was_common = ret->is_common(); - this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, aobject, - aversion); + this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object, + version); if (parameters->options().gc_sections()) this->gc_mark_dyn_syms(ret); ins.first->second = ret; @@ -968,7 +968,7 @@ Symbol_table::add_from_object(Object* aobject, } } - ret->init_object(aname, aversion, aobject, sym, st_shndx, is_ordinary); + ret->init_object(name, version, object, sym, st_shndx, is_ordinary); ins.first->second = ret; if (def) @@ -1055,7 +1055,7 @@ Symbol_table::add_from_relobj( continue; } - const char* aname = sym_names + st_name; + const char* name = sym_names + st_name; bool is_ordinary; unsigned int st_shndx = relobj->adjust_sym_shndx(i + symndx_offset, @@ -1078,7 +1078,7 @@ Symbol_table::add_from_relobj( // In an object file, an '@' in the name separates the symbol // name from the version name. If there are two '@' characters, // this is the default version. - const char* ver = strchr(aname, '@'); + const char* ver = strchr(name, '@'); Stringpool::Key ver_key = 0; int namelen = 0; // DEF: is the version default? LOCAL: is the symbol forced local? @@ -1088,7 +1088,7 @@ Symbol_table::add_from_relobj( if (ver != NULL) { // The symbol name is of the form foo@VERSION or foo@@VERSION - namelen = ver - aname; + namelen = ver - name; ++ver; if (*ver == '@') { @@ -1102,27 +1102,27 @@ Symbol_table::add_from_relobj( // about a common symbol? else { - namelen = strlen(aname); + namelen = strlen(name); if (!this->version_script_.empty() && st_shndx != elfcpp::SHN_UNDEF) { // The symbol name did not have a version, but the // version script may assign a version anyway. - std::string aversion; - if (this->version_script_.get_symbol_version(aname, &aversion)) + std::string version; + if (this->version_script_.get_symbol_version(name, &version)) { // The version can be empty if the version script is // only used to force some symbols to be local. - if (!aversion.empty()) + if (!version.empty()) { - ver = this->namepool_.add_with_length(aversion.c_str(), - aversion.length(), + ver = this->namepool_.add_with_length(version.c_str(), + version.length(), true, &ver_key); def = true; } } - else if (this->version_script_.symbol_is_local(aname)) + else if (this->version_script_.symbol_is_local(name)) local = true; } } @@ -1171,11 +1171,11 @@ Symbol_table::add_from_relobj( } Stringpool::Key name_key; - aname = this->namepool_.add_with_length(aname, namelen, true, + name = this->namepool_.add_with_length(name, namelen, true, &name_key); Sized_symbol<size>* res; - res = this->add_from_object(relobj, aname, name_key, ver, ver_key, + res = this->add_from_object(relobj, name, name_key, ver, ver_key, def, *psym, st_shndx, is_ordinary, orig_st_shndx); @@ -1198,7 +1198,7 @@ template<int size, bool big_endian> Symbol* Symbol_table::add_from_pluginobj( Sized_pluginobj<size, big_endian>* obj, - const char* aname, + const char* name, const char* ver, elfcpp::Sym<size, big_endian>* sym) { @@ -1223,30 +1223,30 @@ Symbol_table::add_from_pluginobj( { // The symbol name did not have a version, but the // version script may assign a version anyway. - std::string aversion; - if (this->version_script_.get_symbol_version(aname, &aversion)) + std::string version; + if (this->version_script_.get_symbol_version(name, &version)) { // The version can be empty if the version script is // only used to force some symbols to be local. - if (!aversion.empty()) + if (!version.empty()) { - ver = this->namepool_.add_with_length(aversion.c_str(), - aversion.length(), + ver = this->namepool_.add_with_length(version.c_str(), + version.length(), true, &ver_key); def = true; } } - else if (this->version_script_.symbol_is_local(aname)) + else if (this->version_script_.symbol_is_local(name)) local = true; } } Stringpool::Key name_key; - aname = this->namepool_.add(aname, true, &name_key); + name = this->namepool_.add(name, true, &name_key); Sized_symbol<size>* res; - res = this->add_from_object(obj, aname, name_key, ver, ver_key, + res = this->add_from_object(obj, name, name_key, ver, ver_key, def, *sym, st_shndx, is_ordinary, st_shndx); if (local) @@ -1337,7 +1337,7 @@ Symbol_table::add_from_dynobj( continue; } - const char* aname = sym_names + st_name; + const char* name = sym_names + st_name; bool is_ordinary; unsigned int st_shndx = dynobj->adjust_sym_shndx(i, psym->get_st_shndx(), @@ -1351,8 +1351,8 @@ Symbol_table::add_from_dynobj( if (versym == NULL) { Stringpool::Key name_key; - aname = this->namepool_.add(aname, true, &name_key); - res = this->add_from_object(dynobj, aname, name_key, NULL, 0, + name = this->namepool_.add(name, true, &name_key); + res = this->add_from_object(dynobj, name, name_key, NULL, 0, false, *psym, st_shndx, is_ordinary, st_shndx); } @@ -1381,13 +1381,13 @@ Symbol_table::add_from_dynobj( // At this point we are definitely going to add this symbol. Stringpool::Key name_key; - aname = this->namepool_.add(aname, true, &name_key); + name = this->namepool_.add(name, true, &name_key); if (v == static_cast<unsigned int>(elfcpp::VER_NDX_LOCAL) || v == static_cast<unsigned int>(elfcpp::VER_NDX_GLOBAL)) { // This symbol does not have a version. - res = this->add_from_object(dynobj, aname, name_key, NULL, 0, + res = this->add_from_object(dynobj, name, name_key, NULL, 0, false, *psym, st_shndx, is_ordinary, st_shndx); } @@ -1400,8 +1400,8 @@ Symbol_table::add_from_dynobj( continue; } - const char* aversion = (*version_map)[v]; - if (aversion == NULL) + const char* version = (*version_map)[v]; + if (version == NULL) { dynobj->error(_("versym for symbol %zu has no name: %u"), i, v); @@ -1409,7 +1409,7 @@ Symbol_table::add_from_dynobj( } Stringpool::Key version_key; - aversion = this->namepool_.add(aversion, true, &version_key); + version = this->namepool_.add(version, true, &version_key); // If this is an absolute symbol, and the version name // and symbol name are the same, then this is the @@ -1419,14 +1419,14 @@ Symbol_table::add_from_dynobj( if (st_shndx == elfcpp::SHN_ABS && !is_ordinary && name_key == version_key) - res = this->add_from_object(dynobj, aname, name_key, NULL, 0, + res = this->add_from_object(dynobj, name, name_key, NULL, 0, false, *psym, st_shndx, is_ordinary, st_shndx); else { const bool def = (!hidden && st_shndx != elfcpp::SHN_UNDEF); - res = this->add_from_object(dynobj, aname, name_key, aversion, + res = this->add_from_object(dynobj, name, name_key, version, version_key, def, *psym, st_shndx, is_ordinary, st_shndx); } @@ -1684,25 +1684,25 @@ Symbol_table::define_special_symbol(const char** pname, const char** pversion, // Define a symbol based on an Output_data. Symbol* -Symbol_table::define_in_output_data(const char* aname, - const char* aversion, +Symbol_table::define_in_output_data(const char* name, + const char* version, Output_data* od, - uint64_t avalue, - uint64_t sym_size, + uint64_t value, + uint64_t symsize, elfcpp::STT type, elfcpp::STB binding, elfcpp::STV visibility, unsigned char nonvis, - bool offset_is_from_the_end, + bool offset_is_from_end, bool only_if_ref) { if (parameters->target().get_size() == 32) { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) - return this->do_define_in_output_data<32>(aname, aversion, od, - avalue, sym_size, type, binding, + return this->do_define_in_output_data<32>(name, version, od, + value, symsize, type, binding, visibility, nonvis, - offset_is_from_the_end, + offset_is_from_end, only_if_ref); #else gold_unreachable(); @@ -1711,10 +1711,10 @@ Symbol_table::define_in_output_data(const char* aname, else if (parameters->target().get_size() == 64) { #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) - return this->do_define_in_output_data<64>(aname, aversion, od, - avalue, sym_size, type, binding, + return this->do_define_in_output_data<64>(name, version, od, + value, symsize, type, binding, visibility, nonvis, - offset_is_from_the_end, + offset_is_from_end, only_if_ref); #else gold_unreachable(); @@ -1729,16 +1729,16 @@ Symbol_table::define_in_output_data(const char* aname, template<int size> Sized_symbol<size>* Symbol_table::do_define_in_output_data( - const char* aname, - const char* aversion, + const char* name, + const char* version, Output_data* od, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, - typename elfcpp::Elf_types<size>::Elf_WXword sym_size, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword symsize, elfcpp::STT type, elfcpp::STB binding, elfcpp::STV visibility, unsigned char nonvis, - bool offset_is_from_the_end, + bool offset_is_from_end, bool only_if_ref) { Sized_symbol<size>* sym; @@ -1748,7 +1748,7 @@ Symbol_table::do_define_in_output_data( if (parameters->target().is_big_endian()) { #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) - sym = this->define_special_symbol<size, true>(&aname, &aversion, + sym = this->define_special_symbol<size, true>(&name, &version, only_if_ref, &oldsym, &resolve_oldsym); #else @@ -1758,7 +1758,7 @@ Symbol_table::do_define_in_output_data( else { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) - sym = this->define_special_symbol<size, false>(&aname, &aversion, + sym = this->define_special_symbol<size, false>(&name, &version, only_if_ref, &oldsym, &resolve_oldsym); #else @@ -1769,15 +1769,15 @@ Symbol_table::do_define_in_output_data( if (sym == NULL) return NULL; - sym->init_output_data(aname, aversion, od, avalue, sym_size, type, binding, - visibility, nonvis, offset_is_from_the_end); + sym->init_output_data(name, version, od, value, symsize, type, binding, + visibility, nonvis, offset_is_from_end); if (oldsym == NULL) { if (binding == elfcpp::STB_LOCAL - || this->version_script_.symbol_is_local(aname)) + || this->version_script_.symbol_is_local(name)) this->force_local(sym); - else if (aversion != NULL) + else if (version != NULL) sym->set_is_default(); return sym; } @@ -1797,24 +1797,24 @@ Symbol_table::do_define_in_output_data( // Define a symbol based on an Output_segment. Symbol* -Symbol_table::define_in_output_segment(const char* aname, - const char* aversion, Output_segment* os, - uint64_t avalue, - uint64_t sym_size, +Symbol_table::define_in_output_segment(const char* name, + const char* version, Output_segment* os, + uint64_t value, + uint64_t symsize, elfcpp::STT type, elfcpp::STB binding, elfcpp::STV visibility, unsigned char nonvis, - Symbol::Segment_offset_base offsetbase, + Symbol::Segment_offset_base offset_base, bool only_if_ref) { if (parameters->target().get_size() == 32) { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) - return this->do_define_in_output_segment<32>(aname, aversion, os, - avalue, sym_size, type, + return this->do_define_in_output_segment<32>(name, version, os, + value, symsize, type, binding, visibility, nonvis, - offsetbase, only_if_ref); + offset_base, only_if_ref); #else gold_unreachable(); #endif @@ -1822,10 +1822,10 @@ Symbol_table::define_in_output_segment(const char* aname, else if (parameters->target().get_size() == 64) { #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) - return this->do_define_in_output_segment<64>(aname, aversion, os, - avalue, sym_size, type, + return this->do_define_in_output_segment<64>(name, version, os, + value, symsize, type, binding, visibility, nonvis, - offsetbase, only_if_ref); + offset_base, only_if_ref); #else gold_unreachable(); #endif @@ -1839,16 +1839,16 @@ Symbol_table::define_in_output_segment(const char* aname, template<int size> Sized_symbol<size>* Symbol_table::do_define_in_output_segment( - const char* aname, - const char* aversion, + const char* name, + const char* version, Output_segment* os, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, - typename elfcpp::Elf_types<size>::Elf_WXword sym_size, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword symsize, elfcpp::STT type, elfcpp::STB binding, elfcpp::STV visibility, unsigned char nonvis, - Symbol::Segment_offset_base offsetbase, + Symbol::Segment_offset_base offset_base, bool only_if_ref) { Sized_symbol<size>* sym; @@ -1858,7 +1858,7 @@ Symbol_table::do_define_in_output_segment( if (parameters->target().is_big_endian()) { #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) - sym = this->define_special_symbol<size, true>(&aname, &aversion, + sym = this->define_special_symbol<size, true>(&name, &version, only_if_ref, &oldsym, &resolve_oldsym); #else @@ -1868,7 +1868,7 @@ Symbol_table::do_define_in_output_segment( else { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) - sym = this->define_special_symbol<size, false>(&aname, &aversion, + sym = this->define_special_symbol<size, false>(&name, &version, only_if_ref, &oldsym, &resolve_oldsym); #else @@ -1879,15 +1879,15 @@ Symbol_table::do_define_in_output_segment( if (sym == NULL) return NULL; - sym->init_output_segment(aname, aversion, os, avalue, sym_size, type, binding, - visibility, nonvis, offsetbase); + sym->init_output_segment(name, version, os, value, symsize, type, binding, + visibility, nonvis, offset_base); if (oldsym == NULL) { if (binding == elfcpp::STB_LOCAL - || this->version_script_.symbol_is_local(aname)) + || this->version_script_.symbol_is_local(name)) this->force_local(sym); - else if (aversion != NULL) + else if (version != NULL) sym->set_is_default(); return sym; } @@ -1908,10 +1908,10 @@ Symbol_table::do_define_in_output_segment( // definition error if this symbol is already defined. Symbol* -Symbol_table::define_as_constant(const char* aname, - const char* aversion, - uint64_t avalue, - uint64_t sym_size, +Symbol_table::define_as_constant(const char* name, + const char* version, + uint64_t value, + uint64_t symsize, elfcpp::STT type, elfcpp::STB binding, elfcpp::STV visibility, @@ -1922,8 +1922,8 @@ Symbol_table::define_as_constant(const char* aname, if (parameters->target().get_size() == 32) { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG) - return this->do_define_as_constant<32>(aname, aversion, avalue, - sym_size, type, binding, + return this->do_define_as_constant<32>(name, version, value, + symsize, type, binding, visibility, nonvis, only_if_ref, force_override); #else @@ -1933,8 +1933,8 @@ Symbol_table::define_as_constant(const char* aname, else if (parameters->target().get_size() == 64) { #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) - return this->do_define_as_constant<64>(aname, aversion, avalue, - sym_size, type, binding, + return this->do_define_as_constant<64>(name, version, value, + symsize, type, binding, visibility, nonvis, only_if_ref, force_override); #else @@ -1950,10 +1950,10 @@ Symbol_table::define_as_constant(const char* aname, template<int size> Sized_symbol<size>* Symbol_table::do_define_as_constant( - const char* aname, - const char* aversion, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, - typename elfcpp::Elf_types<size>::Elf_WXword sym_size, + const char* name, + const char* version, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword symsize, elfcpp::STT type, elfcpp::STB binding, elfcpp::STV visibility, @@ -1968,7 +1968,7 @@ Symbol_table::do_define_as_constant( if (parameters->target().is_big_endian()) { #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) - sym = this->define_special_symbol<size, true>(&aname, &aversion, + sym = this->define_special_symbol<size, true>(&name, &version, only_if_ref, &oldsym, &resolve_oldsym); #else @@ -1978,7 +1978,7 @@ Symbol_table::do_define_as_constant( else { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) - sym = this->define_special_symbol<size, false>(&aname, &aversion, + sym = this->define_special_symbol<size, false>(&name, &version, only_if_ref, &oldsym, &resolve_oldsym); #else @@ -1989,21 +1989,21 @@ Symbol_table::do_define_as_constant( if (sym == NULL) return NULL; - sym->init_constant(aname, aversion, avalue, sym_size, type, binding, visibility, + sym->init_constant(name, version, value, symsize, type, binding, visibility, nonvis); if (oldsym == NULL) { // Version symbols are absolute symbols with name == version. // We don't want to force them to be local. - if ((aversion == NULL - || aname != aversion - || avalue != 0) + if ((version == NULL + || name != version + || value != 0) && (binding == elfcpp::STB_LOCAL - || this->version_script_.symbol_is_local(aname))) + || this->version_script_.symbol_is_local(name))) this->force_local(sym); - else if (aversion != NULL - && (aname != aversion || avalue != 0)) + else if (version != NULL + && (name != version || value != 0)) sym->set_is_default(); return sym; } @@ -2079,13 +2079,13 @@ void Symbol_table::define_with_copy_reloc( Sized_symbol<size>* csym, Output_data* posd, - typename elfcpp::Elf_types<size>::Elf_Addr avalue) + typename elfcpp::Elf_types<size>::Elf_Addr value) { gold_assert(csym->is_from_dynobj()); gold_assert(!csym->is_copied_from_dynobj()); - Object* aobject = csym->object(); - gold_assert(aobject->is_dynamic()); - Dynobj* dynobj = static_cast<Dynobj*>(aobject); + Object* object = csym->object(); + gold_assert(object->is_dynamic()); + Dynobj* dynobj = static_cast<Dynobj*>(object); // Our copied variable has to override any variable in a shared // library. @@ -2094,7 +2094,7 @@ Symbol_table::define_with_copy_reloc( binding = elfcpp::STB_GLOBAL; this->define_in_output_data(csym->name(), csym->version(), - posd, avalue, csym->symsize(), + posd, value, csym->symsize(), csym->type(), binding, csym->visibility(), csym->nonvis(), false, false); @@ -2172,12 +2172,12 @@ Symbol_table::do_add_undefined_symbols_from_command_line() p != parameters->options().undefined_end(); ++p) { - const char* aname = p->c_str(); + const char* name = p->c_str(); - if (this->lookup(aname) != NULL) + if (this->lookup(name) != NULL) continue; - const char* aversion = NULL; + const char* version = NULL; Sized_symbol<size>* sym; Sized_symbol<size>* oldsym; @@ -2185,7 +2185,7 @@ Symbol_table::do_add_undefined_symbols_from_command_line() if (parameters->target().is_big_endian()) { #if defined(HAVE_TARGET_32_BIG) || defined(HAVE_TARGET_64_BIG) - sym = this->define_special_symbol<size, true>(&aname, &aversion, + sym = this->define_special_symbol<size, true>(&name, &version, false, &oldsym, &resolve_oldsym); #else @@ -2195,7 +2195,7 @@ Symbol_table::do_add_undefined_symbols_from_command_line() else { #if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_64_LITTLE) - sym = this->define_special_symbol<size, false>(&aname, &aversion, + sym = this->define_special_symbol<size, false>(&name, &version, false, &oldsym, &resolve_oldsym); #else @@ -2205,7 +2205,7 @@ Symbol_table::do_add_undefined_symbols_from_command_line() gold_assert(oldsym == NULL); - sym->init_undefined(aname, aversion, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, + sym->init_undefined(name, version, elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, elfcpp::STV_DEFAULT, 0); ++this->saw_undefined_; } @@ -2375,18 +2375,18 @@ Symbol_table::compute_final_value( Compute_final_value_status* pstatus) const { typedef typename Sized_symbol<size>::Value_type Value_type; - Value_type avalue; + Value_type value; switch (sym->source()) { case Symbol::FROM_OBJECT: { bool is_ordinary; - unsigned int sec_shndx = sym->shndx(&is_ordinary); + unsigned int shndx = sym->shndx(&is_ordinary); if (!is_ordinary - && sec_shndx != elfcpp::SHN_ABS - && !Symbol::is_common_shndx(sec_shndx)) + && shndx != elfcpp::SHN_ABS + && !Symbol::is_common_shndx(shndx)) { *pstatus = CFVS_UNSUPPORTED_SYMBOL_SECTION; return 0; @@ -2395,32 +2395,32 @@ Symbol_table::compute_final_value( Object* symobj = sym->object(); if (symobj->is_dynamic()) { - avalue = 0; - sec_shndx = elfcpp::SHN_UNDEF; + value = 0; + shndx = elfcpp::SHN_UNDEF; } else if (symobj->pluginobj() != NULL) { - avalue = 0; - sec_shndx = elfcpp::SHN_UNDEF; + value = 0; + shndx = elfcpp::SHN_UNDEF; } - else if (sec_shndx == elfcpp::SHN_UNDEF) - avalue = 0; + else if (shndx == elfcpp::SHN_UNDEF) + value = 0; else if (!is_ordinary - && (sec_shndx == elfcpp::SHN_ABS - || Symbol::is_common_shndx(sec_shndx))) - avalue = sym->value(); + && (shndx == elfcpp::SHN_ABS + || Symbol::is_common_shndx(shndx))) + value = sym->value(); else { Relobj* relobj = static_cast<Relobj*>(symobj); - Output_section* os = relobj->output_section(sec_shndx); - uint64_t secoff64 = relobj->output_section_offset(sec_shndx); + Output_section* os = relobj->output_section(shndx); + uint64_t secoff64 = relobj->output_section_offset(shndx); - if (this->is_section_folded(relobj, sec_shndx)) + if (this->is_section_folded(relobj, shndx)) { gold_assert(os == NULL); // Get the os of the section it is folded onto. Section_id folded = this->icf_->get_folded_section(relobj, - sec_shndx); + shndx); gold_assert(folded.first != NULL); Relobj* folded_obj = reinterpret_cast<Relobj*>(folded.first); os = folded_obj->output_section(folded.second); @@ -2442,16 +2442,16 @@ Symbol_table::compute_final_value( { // The section needs special handling (e.g., a merge section). - avalue = os->output_address(relobj, sec_shndx, sym->value()); + value = os->output_address(relobj, shndx, sym->value()); } else { Value_type secoff = convert_types<Value_type, uint64_t>(secoff64); if (sym->type() == elfcpp::STT_TLS) - avalue = sym->value() + os->tls_offset() + secoff; + value = sym->value() + os->tls_offset() + secoff; else - avalue = sym->value() + os->address() + secoff; + value = sym->value() + os->address() + secoff; } } } @@ -2460,35 +2460,35 @@ Symbol_table::compute_final_value( case Symbol::IN_OUTPUT_DATA: { Output_data* od = sym->output_data(); - avalue = sym->value(); + value = sym->value(); if (sym->type() != elfcpp::STT_TLS) - avalue += od->address(); + value += od->address(); else { Output_section* os = od->output_section(); gold_assert(os != NULL); - avalue += os->tls_offset() + (od->address() - os->address()); + value += os->tls_offset() + (od->address() - os->address()); } if (sym->offset_is_from_end()) - avalue += od->data_size(); + value += od->data_size(); } break; case Symbol::IN_OUTPUT_SEGMENT: { Output_segment* os = sym->output_segment(); - avalue = sym->value(); + value = sym->value(); if (sym->type() != elfcpp::STT_TLS) - avalue += os->vaddr(); + value += os->vaddr(); switch (sym->offset_base()) { case Symbol::SEGMENT_START: break; case Symbol::SEGMENT_END: - avalue += os->memsz(); + value += os->memsz(); break; case Symbol::SEGMENT_BSS: - avalue += os->filesz(); + value += os->filesz(); break; default: gold_unreachable(); @@ -2497,11 +2497,11 @@ Symbol_table::compute_final_value( break; case Symbol::IS_CONSTANT: - avalue = sym->value(); + value = sym->value(); break; case Symbol::IS_UNDEFINED: - avalue = 0; + value = 0; break; default: @@ -2509,7 +2509,7 @@ Symbol_table::compute_final_value( } *pstatus = CFVS_OK; - return avalue; + return value; } // Finalize the symbol SYM. This returns true if the symbol should be @@ -2538,7 +2538,7 @@ Symbol_table::sized_finalize_symbol(Symbol* unsized_sym) // Compute final symbol value. Compute_final_value_status status; - Value_type avalue = this->compute_final_value(sym, &status); + Value_type value = this->compute_final_value(sym, &status); switch (status) { @@ -2547,9 +2547,9 @@ Symbol_table::sized_finalize_symbol(Symbol* unsized_sym) case CFVS_UNSUPPORTED_SYMBOL_SECTION: { bool is_ordinary; - unsigned int sec_shndx = sym->shndx(&is_ordinary); + unsigned int shndx = sym->shndx(&is_ordinary); gold_error(_("%s: unsupported symbol section 0x%x"), - sym->demangled_name().c_str(), sec_shndx); + sym->demangled_name().c_str(), shndx); } break; case CFVS_NO_OUTPUT_SECTION: @@ -2559,7 +2559,7 @@ Symbol_table::sized_finalize_symbol(Symbol* unsized_sym) gold_unreachable(); } - sym->set_value(avalue); + sym->set_value(value); if (parameters->options().strip_all() || !parameters->options().should_retain_symbol(sym->name())) @@ -2666,7 +2666,7 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, continue; } - unsigned int sec_shndx; + unsigned int shndx; typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value(); typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value; switch (sym->source()) @@ -2682,7 +2682,7 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, { gold_error(_("%s: unsupported symbol section 0x%x"), sym->demangled_name().c_str(), in_shndx); - sec_shndx = in_shndx; + shndx = in_shndx; } else { @@ -2691,15 +2691,15 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, { if (sym->needs_dynsym_value()) dynsym_value = target.dynsym_value(sym); - sec_shndx = elfcpp::SHN_UNDEF; + shndx = elfcpp::SHN_UNDEF; } else if (symobj->pluginobj() != NULL) - sec_shndx = elfcpp::SHN_UNDEF; + shndx = elfcpp::SHN_UNDEF; else if (in_shndx == elfcpp::SHN_UNDEF || (!is_ordinary && (in_shndx == elfcpp::SHN_ABS || Symbol::is_common_shndx(in_shndx)))) - sec_shndx = in_shndx; + shndx = in_shndx; else { Relobj* relobj = static_cast<Relobj*>(symobj); @@ -2718,15 +2718,15 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, gold_assert(os != NULL); } gold_assert(os != NULL); - sec_shndx = os->out_shndx(); + shndx = os->out_shndx(); - if (sec_shndx >= elfcpp::SHN_LORESERVE) + if (shndx >= elfcpp::SHN_LORESERVE) { if (sym_index != -1U) - symtab_xindex->add(sym_index, sec_shndx); + symtab_xindex->add(sym_index, shndx); if (dynsym_index != -1U) - dynsym_xindex->add(dynsym_index, sec_shndx); - sec_shndx = elfcpp::SHN_XINDEX; + dynsym_xindex->add(dynsym_index, shndx); + shndx = elfcpp::SHN_XINDEX; } // In object files symbol values are section @@ -2739,27 +2739,27 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, break; case Symbol::IN_OUTPUT_DATA: - sec_shndx = sym->output_data()->out_shndx(); - if (sec_shndx >= elfcpp::SHN_LORESERVE) + shndx = sym->output_data()->out_shndx(); + if (shndx >= elfcpp::SHN_LORESERVE) { if (sym_index != -1U) - symtab_xindex->add(sym_index, sec_shndx); + symtab_xindex->add(sym_index, shndx); if (dynsym_index != -1U) - dynsym_xindex->add(dynsym_index, sec_shndx); - sec_shndx = elfcpp::SHN_XINDEX; + dynsym_xindex->add(dynsym_index, shndx); + shndx = elfcpp::SHN_XINDEX; } break; case Symbol::IN_OUTPUT_SEGMENT: - sec_shndx = elfcpp::SHN_ABS; + shndx = elfcpp::SHN_ABS; break; case Symbol::IS_CONSTANT: - sec_shndx = elfcpp::SHN_ABS; + shndx = elfcpp::SHN_ABS; break; case Symbol::IS_UNDEFINED: - sec_shndx = elfcpp::SHN_UNDEF; + shndx = elfcpp::SHN_UNDEF; break; default: @@ -2771,7 +2771,7 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, sym_index -= first_global_index; gold_assert(sym_index < output_count); unsigned char* ps = psyms + (sym_index * sym_size); - this->sized_write_symbol<size, big_endian>(sym, sym_value, sec_shndx, + this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx, sympool, ps); } @@ -2780,7 +2780,7 @@ Symbol_table::sized_write_globals(const Stringpool* sympool, dynsym_index -= first_dynamic_global_index; gold_assert(dynsym_index < dynamic_count); unsigned char* pd = dynamic_view + (dynsym_index * sym_size); - this->sized_write_symbol<size, big_endian>(sym, dynsym_value, sec_shndx, + this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx, dynpool, pd); } } @@ -2797,16 +2797,16 @@ template<int size, bool big_endian> void Symbol_table::sized_write_symbol( Sized_symbol<size>* sym, - typename elfcpp::Elf_types<size>::Elf_Addr avalue, - unsigned int sec_shndx, + typename elfcpp::Elf_types<size>::Elf_Addr value, + unsigned int shndx, const Stringpool* pool, unsigned char* p) const { elfcpp::Sym_write<size, big_endian> osym(p); osym.put_st_name(pool->get_offset(sym->name())); - osym.put_st_value(avalue); + osym.put_st_value(value); // Use a symbol size of zero for undefined symbols from shared libraries. - if (sec_shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj()) + if (shndx == elfcpp::SHN_UNDEF && sym->is_from_dynobj()) osym.put_st_size(0); else osym.put_st_size(sym->symsize()); @@ -2821,7 +2821,7 @@ Symbol_table::sized_write_symbol( else osym.put_st_info(elfcpp::elf_st_info(sym->binding(), type)); osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis())); - osym.put_st_shndx(sec_shndx); + osym.put_st_shndx(shndx); } // Check for unresolved symbols in shared libraries. This is @@ -2920,13 +2920,13 @@ Symbol_table::sized_write_section_symbol(const Output_section* os, elfcpp::STT_SECTION)); osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0)); - unsigned int sec_shndx = os->out_shndx(); - if (sec_shndx >= elfcpp::SHN_LORESERVE) + unsigned int shndx = os->out_shndx(); + if (shndx >= elfcpp::SHN_LORESERVE) { - symtab_xindex->add(os->symtab_index(), sec_shndx); - sec_shndx = elfcpp::SHN_XINDEX; + symtab_xindex->add(os->symtab_index(), shndx); + shndx = elfcpp::SHN_XINDEX; } - osym.put_st_shndx(sec_shndx); + osym.put_st_shndx(shndx); of->write_output_view(offset, sym_size, pov); } @@ -3029,11 +3029,11 @@ Symbol_table::detect_odr_violations(const Task* task, // Add a new warning. void -Warnings::add_warning(Symbol_table* symtab, const char* aname, Object* obj, +Warnings::add_warning(Symbol_table* symtab, const char* name, Object* obj, const std::string& warning) { - aname = symtab->canonicalize_name(aname); - this->warnings_[aname].set(obj, warning); + name = symtab->canonicalize_name(name); + this->warnings_[name].set(obj, warning); } // Look through the warnings and mark the symbols for which we should @@ -3253,7 +3253,7 @@ void Symbol_table::define_with_copy_reloc<32>( Sized_symbol<32>* sym, Output_data* posd, - elfcpp::Elf_types<32>::Elf_Addr avalue); + elfcpp::Elf_types<32>::Elf_Addr value); #endif #if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG) @@ -3262,7 +3262,7 @@ void Symbol_table::define_with_copy_reloc<64>( Sized_symbol<64>* sym, Output_data* posd, - elfcpp::Elf_types<64>::Elf_Addr avalue); + elfcpp::Elf_types<64>::Elf_Addr value); #endif #ifdef HAVE_TARGET_32_LITTLE diff --git a/gold/symtab.h b/gold/symtab.h index 2beece8..c153150 100644 --- a/gold/symtab.h +++ b/gold/symtab.h @@ -220,8 +220,8 @@ class Symbol // Set the visibility. void - set_visibility(elfcpp::STV vis) - { this->visibility_ = vis; } + set_visibility(elfcpp::STV visibility) + { this->visibility_ = visibility; } // Override symbol visibility. void @@ -368,15 +368,15 @@ class Symbol unsigned int got_offset(unsigned int got_type) const { - unsigned int got_off = this->got_offsets_.get_offset(got_type); - gold_assert(got_off != -1U); - return got_off; + unsigned int got_offset = this->got_offsets_.get_offset(got_type); + gold_assert(got_offset != -1U); + return got_offset; } // Set the GOT offset of this symbol. void - set_got_offset(unsigned int got_type, unsigned int got_off) - { this->got_offsets_.set_offset(got_type, got_off); } + set_got_offset(unsigned int got_type, unsigned int got_offset) + { this->got_offsets_.set_offset(got_type, got_offset); } // Return whether this symbol has an entry in the PLT section. bool @@ -393,10 +393,10 @@ class Symbol // Set the PLT offset of this symbol. void - set_plt_offset(unsigned int plt_off) + set_plt_offset(unsigned int plt_offset) { this->has_plt_offset_ = true; - this->plt_offset_ = plt_off; + this->plt_offset_ = plt_offset; } // Return whether this dynamic symbol needs a special value in the @@ -432,10 +432,10 @@ class Symbol bool is_ordinary; if (this->source_ != FROM_OBJECT) return this->source_ != IS_UNDEFINED; - unsigned int sec_shndx = this->shndx(&is_ordinary); + unsigned int shndx = this->shndx(&is_ordinary); return (is_ordinary - ? sec_shndx != elfcpp::SHN_UNDEF - : !Symbol::is_common_shndx(sec_shndx)); + ? shndx != elfcpp::SHN_UNDEF + : !Symbol::is_common_shndx(shndx)); } // Return true if this symbol is from a dynamic object. @@ -481,8 +481,8 @@ class Symbol if (this->source_ != FROM_OBJECT) return false; bool is_ordinary; - unsigned int sec_shndx = this->shndx(&is_ordinary); - return !is_ordinary && Symbol::is_common_shndx(sec_shndx); + unsigned int shndx = this->shndx(&is_ordinary); + return !is_ordinary && Symbol::is_common_shndx(shndx); } // Return whether this symbol can be seen outside this object. @@ -1004,14 +1004,14 @@ class Sized_symbol : public Symbol // Set the symbol size. This is used when resolving common symbols. void - set_symsize(Size_type symsz) - { this->symsize_ = symsz; } + set_symsize(Size_type symsize) + { this->symsize_ = symsize; } // Set the symbol value. This is called when we store the final // values of the symbols into the symbol table. void - set_value(Value_type val) - { this->value_ = val; } + set_value(Value_type value) + { this->value_ = value; } // Allocate a common symbol by giving it a location in the output // file. @@ -1184,8 +1184,8 @@ class Symbol_table ~Symbol_table(); void - set_icf(Icf* _icf) - { this->icf_ = _icf;} + set_icf(Icf* icf) + { this->icf_ = icf;} Icf* icf() const @@ -1196,8 +1196,8 @@ class Symbol_table is_section_folded(Object* obj, unsigned int shndx) const; void - set_gc(Garbage_collection* garbage) - { this->gc_ = garbage; } + set_gc(Garbage_collection* gc) + { this->gc_ = gc; } Garbage_collection* gc() const diff --git a/gold/target-select.cc b/gold/target-select.cc index ac311fb..dcd3017 100644 --- a/gold/target-select.cc +++ b/gold/target-select.cc @@ -1,6 +1,6 @@ // target-select.cc -- select a target for an object file -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -43,10 +43,10 @@ namespace gold // list. This runs at global constructor time, so we want it to be // fast. -Target_selector::Target_selector(int amachine, int size, bool is_big_end, - const char* bfdname) - : machine_(amachine), size_(size), is_big_endian_(is_big_end), - bfd_name_(bfdname), instantiated_target_(NULL), lock_(NULL), +Target_selector::Target_selector(int machine, int size, bool is_big_endian, + const char* bfd_name) + : machine_(machine), size_(size), is_big_endian_(is_big_endian), + bfd_name_(bfd_name), instantiated_target_(NULL), lock_(NULL), initialize_lock_(&this->lock_) { diff --git a/gold/target-select.h b/gold/target-select.h index c5f469b..d1cd44f 100644 --- a/gold/target-select.h +++ b/gold/target-select.h @@ -1,6 +1,6 @@ // target-select.h -- select a target for an object file -*- C++ -*- -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -57,8 +57,8 @@ class Target_selector // If we can handle this target, return a pointer to a target // structure. The size and endianness are known. Target* - recognize(int mach, int osabi, int abiversion) - { return this->do_recognize(mach, osabi, abiversion); } + recognize(int machine, int osabi, int abiversion) + { return this->do_recognize(machine, osabi, abiversion); } // If NAME matches the target, return a pointer to a target // structure. diff --git a/gold/testsuite/tls_test_main.cc b/gold/testsuite/tls_test_main.cc index 877889c..0ff02c6 100644 --- a/gold/testsuite/tls_test_main.cc +++ b/gold/testsuite/tls_test_main.cc @@ -33,16 +33,16 @@ #define safe_lock(muptr) \ do \ { \ - int pthread_err = pthread_mutex_lock(muptr); \ - assert(pthread_err == 0); \ + int err = pthread_mutex_lock(muptr); \ + assert(err == 0); \ } \ while (0) #define safe_unlock(muptr) \ do \ { \ - int pthread_err = pthread_mutex_unlock(muptr); \ - assert(pthread_err == 0); \ + int err = pthread_mutex_unlock(muptr); \ + assert(err == 0); \ } \ while (0) diff --git a/gold/token.h b/gold/token.h index d477be1..dcf00b6 100644 --- a/gold/token.h +++ b/gold/token.h @@ -91,8 +91,8 @@ class Task_list class Task_token { public: - Task_token(bool tis_blocker) - : is_blocker_(tis_blocker), blockers_(0), writer_(NULL), waiting_() + Task_token(bool is_blocker) + : is_blocker_(is_blocker), blockers_(0), writer_(NULL), waiting_() { } ~Task_token() diff --git a/gold/workqueue.cc b/gold/workqueue.cc index 565c7fd..18c3900 100644 --- a/gold/workqueue.cc +++ b/gold/workqueue.cc @@ -1,6 +1,6 @@ // workqueue.cc -- the workqueue for gold -// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc. +// Copyright 2006, 2007, 2008 Free Software Foundation, Inc. // Written by Ian Lance Taylor <iant@google.com>. // This file is part of gold. @@ -148,7 +148,7 @@ Workqueue::~Workqueue() // waiting for a Token. void -Workqueue::add_to_queue(Task_list* que, Task* t, bool front) +Workqueue::add_to_queue(Task_list* queue, Task* t, bool front) { Hold_lock hl(this->lock_); @@ -164,9 +164,9 @@ Workqueue::add_to_queue(Task_list* que, Task* t, bool front) else { if (front) - que->push_front(t); + queue->push_front(t); else - que->push_back(t); + queue->push_back(t); // Tell any waiting thread that there is work to do. this->condvar_.signal(); } @@ -441,11 +441,11 @@ Workqueue::release_locks(Task* t, Task_locker* tl) { // The token has been unblocked. Every waiting Task may // now be runnable. - Task* tok; - while ((tok = token->remove_first_waiting()) != NULL) + Task* t; + while ((t = token->remove_first_waiting()) != NULL) { --this->waiting_; - this->return_or_queue(tok, true, &ret); + this->return_or_queue(t, true, &ret); } } } @@ -458,11 +458,11 @@ Workqueue::release_locks(Task* t, Task_locker* tl) // move all the Tasks to the runnable queue, to avoid a // potential deadlock if the locking status changes before // we run the next thread. - Task* tok; - while ((tok = token->remove_first_waiting()) != NULL) + Task* t; + while ((t = token->remove_first_waiting()) != NULL) { --this->waiting_; - if (this->return_or_queue(tok, false, &ret)) + if (this->return_or_queue(t, false, &ret)) break; } } diff --git a/gold/workqueue.h b/gold/workqueue.h index a17ec9d..7545224 100644 --- a/gold/workqueue.h +++ b/gold/workqueue.h @@ -150,8 +150,8 @@ class Task_function : public Task // RUNNER and BLOCKER should be allocated using new, and will be // deleted after the task runs. Task_function(Task_function_runner* runner, Task_token* blocker, - const char* tname) - : runner_(runner), blocker_(blocker), name_(tname) + const char* name) + : runner_(runner), blocker_(blocker), name_(name) { } ~Task_function() diff --git a/gold/x86_64.cc b/gold/x86_64.cc index 00fbf3f..e51b4ab 100644 --- a/gold/x86_64.cc +++ b/gold/x86_64.cc @@ -702,10 +702,10 @@ unsigned char Output_data_plt_x86_64::tlsdesc_plt_entry[plt_entry_size] = void Output_data_plt_x86_64::do_write(Output_file* of) { - const off_t off = this->offset(); + const off_t offset = this->offset(); const section_size_type oview_size = convert_to_section_size_type(this->data_size()); - unsigned char* const oview = of->get_output_view(off, oview_size); + unsigned char* const oview = of->get_output_view(offset, oview_size); const off_t got_file_offset = this->got_plt_->offset(); const section_size_type got_size = @@ -785,7 +785,7 @@ Output_data_plt_x86_64::do_write(Output_file* of) gold_assert(static_cast<section_size_type>(pov - oview) == oview_size); gold_assert(static_cast<section_size_type>(got_pov - got_view) == got_size); - of->write_output_view(off, oview_size, oview); + of->write_output_view(offset, oview_size, oview); of->write_output_view(got_file_offset, got_size, got_view); } |