// target.h -- target support for gold -*- C++ -*-
+// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Written by Ian Lance Taylor <iant@google.com>.
+
+// This file is part of gold.
+
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+// MA 02110-1301, USA.
+
// The abstract class Target is the interface for target specific
// support. It defines abstract methods which each target must
// implement. Typically there will be one target per processor, but
#ifndef GOLD_TARGET_H
#define GOLD_TARGET_H
-#include <cassert>
-
#include "elfcpp.h"
-#include "symtab.h"
namespace gold
{
class General_options;
class Object;
template<int size, bool big_endian>
-class Sized_object;
+class Sized_relobj;
template<int size, bool big_endian>
struct Relocate_info;
+class Symbol;
+template<int size>
+class Sized_symbol;
+class Symbol_table;
// The abstract class for target specific handling.
has_resolve() const
{ return this->pti_->has_resolve; }
+ // Whether this target has a specific code fill function.
+ bool
+ has_code_fill() const
+ { return this->pti_->has_code_fill; }
+
+ // Return the default name of the dynamic linker.
+ const char*
+ dynamic_linker() const
+ { return this->pti_->dynamic_linker; }
+
// Return the default address to use for the text segment.
uint64_t
text_segment_address() const
common_pagesize() const
{ return this->pti_->common_pagesize; }
+ // This is called to tell the target to complete any sections it is
+ // handling. After this all sections must have their final size.
+ void
+ finalize_sections(Layout* layout)
+ { return this->do_finalize_sections(layout); }
+
+ // Return a string to use to fill out a code section. This is
+ // basically one or more NOPS which must fill out the specified
+ // length in bytes.
+ std::string
+ code_fill(off_t length)
+ { return this->do_code_fill(length); }
+
protected:
// This struct holds the constant information for a child class. We
// use a struct to avoid the overhead of virtual function calls for
bool has_make_symbol;
// Whether this target has a specific resolve function.
bool has_resolve;
+ // Whether this target has a specific code fill function.
+ bool has_code_fill;
+ // The default dynamic linker name.
+ const char* dynamic_linker;
// The default text segment address.
uint64_t text_segment_address;
// The ABI specified page size.
: pti_(pti)
{ }
+ // Virtual function which may be implemented by the child class.
+ virtual void
+ do_finalize_sections(Layout*)
+ { }
+
+ // Virtual function which must be implemented by the child class if
+ // needed.
+ virtual std::string
+ do_code_fill(off_t)
+ { gold_unreachable(); }
+
private:
Target(const Target&);
Target& operator=(const Target&);
// symbol table. This will only be called if has_make_symbol()
// returns true.
virtual Sized_symbol<size>*
- make_symbol()
- { abort(); }
+ make_symbol() const
+ { gold_unreachable(); }
// Resolve a symbol for the target. This should be overridden by a
// target which needs to take special action. TO is the
// pre-existing symbol. SYM is the new symbol, seen in OBJECT.
- // This will only be called if has_resolve() returns true.
+ // VERSION is the version of SYM. This will only be called if
+ // has_resolve() returns true.
virtual void
- resolve(Symbol*, const elfcpp::Sym<size, big_endian>&, Object*)
- { abort(); }
+ resolve(Symbol*, const elfcpp::Sym<size, big_endian>&, Object*,
+ const char*)
+ { gold_unreachable(); }
// Scan the relocs for a section, and record any information
// required for the symbol. OPTIONS is the command line options.
// SYMTAB is the symbol table. OBJECT is the object in which the
- // section appears. SH_TYPE is the type of the relocation section,
+ // section appears. DATA_SHNDX is the section index that these
+ // relocs apply to. SH_TYPE is the type of the relocation section,
// SHT_REL or SHT_RELA. PRELOCS points to the relocation data.
// RELOC_COUNT is the number of relocs. LOCAL_SYMBOL_COUNT is the
// number of local symbols. PLOCAL_SYMBOLS points to the local
virtual void
scan_relocs(const General_options& options,
Symbol_table* symtab,
- Sized_object<size, big_endian>* object,
+ Layout* layout,
+ Sized_relobj<size, big_endian>* object,
+ unsigned int data_shndx,
unsigned int sh_type,
const unsigned char* prelocs,
size_t reloc_count,
Sized_target(const Target::Target_info* pti)
: Target(pti)
{
- assert(pti->size == size);
- assert(pti->is_big_endian ? big_endian : !big_endian);
+ gold_assert(pti->size == size);
+ gold_assert(pti->is_big_endian ? big_endian : !big_endian);
}
};
OSDN Git Service
