• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- lib/CodeGen/ELF.h - ELF constants and data structures ---*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This header contains common, non-processor-specific data structures and
11 // constants for the ELF file format.
12 //
13 // The details of the ELF32 bits in this file are largely based on the Tool
14 // Interface Standard (TIS) Executable and Linking Format (ELF) Specification
15 // Version 1.2, May 1995. The ELF64 is based on HP/Intel definition of the
16 // ELF-64 object file format document, Version 1.5 Draft 2 May 27, 1998
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #ifndef CODEGEN_ELF_H
21 #define CODEGEN_ELF_H
22 
23 #include "llvm/CodeGen/BinaryObject.h"
24 #include "llvm/CodeGen/MachineRelocation.h"
25 #include "llvm/Support/ELF.h"
26 #include "llvm/Support/DataTypes.h"
27 
28 namespace llvm {
29   class GlobalValue;
30 
31   /// ELFSym - This struct contains information about each symbol that is
32   /// added to logical symbol table for the module.  This is eventually
33   /// turned into a real symbol table in the file.
34   struct ELFSym {
35 
36     // ELF symbols are related to llvm ones by being one of the two llvm
37     // types, for the other ones (section, file, func) a null pointer is
38     // assumed by default.
39     union {
40       const GlobalValue *GV;  // If this is a pointer to a GV
41       const char *Ext;        // If this is a pointer to a named symbol
42     } Source;
43 
44     // Describes from which source type this ELF symbol comes from,
45     // they can be GlobalValue, ExternalSymbol or neither.
46     enum {
47       isGV,      // The Source.GV field is valid.
48       isExtSym,  // The Source.ExtSym field is valid.
49       isOther    // Not a GlobalValue or External Symbol
50     };
51     unsigned SourceType;
52 
isGlobalValueELFSym53     bool isGlobalValue() const { return SourceType == isGV; }
isExternalSymELFSym54     bool isExternalSym() const { return SourceType == isExtSym; }
55 
56     // getGlobalValue - If this is a global value which originated the
57     // elf symbol, return a reference to it.
getGlobalValueELFSym58     const GlobalValue *getGlobalValue() const {
59       assert(SourceType == isGV && "This is not a global value");
60       return Source.GV;
61     }
62 
63     // getExternalSym - If this is an external symbol which originated the
64     // elf symbol, return a reference to it.
getExternalSymbolELFSym65     const char *getExternalSymbol() const {
66       assert(SourceType == isExtSym && "This is not an external symbol");
67       return Source.Ext;
68     }
69 
70     // getGV - From a global value return a elf symbol to represent it
getGVELFSym71     static ELFSym *getGV(const GlobalValue *GV, unsigned Bind,
72                          unsigned Type, unsigned Visibility) {
73       ELFSym *Sym = new ELFSym();
74       Sym->Source.GV = GV;
75       Sym->setBind(Bind);
76       Sym->setType(Type);
77       Sym->setVisibility(Visibility);
78       Sym->SourceType = isGV;
79       return Sym;
80     }
81 
82     // getExtSym - Create and return an elf symbol to represent an
83     // external symbol
getExtSymELFSym84     static ELFSym *getExtSym(const char *Ext) {
85       ELFSym *Sym = new ELFSym();
86       Sym->Source.Ext = Ext;
87       Sym->setBind(ELF::STB_GLOBAL);
88       Sym->setType(ELF::STT_NOTYPE);
89       Sym->setVisibility(ELF::STV_DEFAULT);
90       Sym->SourceType = isExtSym;
91       return Sym;
92     }
93 
94     // getSectionSym - Returns a elf symbol to represent an elf section
getSectionSymELFSym95     static ELFSym *getSectionSym() {
96       ELFSym *Sym = new ELFSym();
97       Sym->setBind(ELF::STB_LOCAL);
98       Sym->setType(ELF::STT_SECTION);
99       Sym->setVisibility(ELF::STV_DEFAULT);
100       Sym->SourceType = isOther;
101       return Sym;
102     }
103 
104     // getFileSym - Returns a elf symbol to represent the module identifier
getFileSymELFSym105     static ELFSym *getFileSym() {
106       ELFSym *Sym = new ELFSym();
107       Sym->setBind(ELF::STB_LOCAL);
108       Sym->setType(ELF::STT_FILE);
109       Sym->setVisibility(ELF::STV_DEFAULT);
110       Sym->SectionIdx = 0xfff1;  // ELFSection::SHN_ABS;
111       Sym->SourceType = isOther;
112       return Sym;
113     }
114 
115     // getUndefGV - Returns a STT_NOTYPE symbol
getUndefGVELFSym116     static ELFSym *getUndefGV(const GlobalValue *GV, unsigned Bind) {
117       ELFSym *Sym = new ELFSym();
118       Sym->Source.GV = GV;
119       Sym->setBind(Bind);
120       Sym->setType(ELF::STT_NOTYPE);
121       Sym->setVisibility(ELF::STV_DEFAULT);
122       Sym->SectionIdx = 0;  //ELFSection::SHN_UNDEF;
123       Sym->SourceType = isGV;
124       return Sym;
125     }
126 
127     // ELF specific fields
128     unsigned NameIdx;         // Index in .strtab of name, once emitted.
129     uint64_t Value;
130     unsigned Size;
131     uint8_t Info;
132     uint8_t Other;
133     unsigned short SectionIdx;
134 
135     // Symbol index into the Symbol table
136     unsigned SymTabIdx;
137 
ELFSymELFSym138     ELFSym() : SourceType(isOther), NameIdx(0), Value(0),
139                Size(0), Info(0), Other(ELF::STV_DEFAULT), SectionIdx(0),
140                SymTabIdx(0) {}
141 
getBindELFSym142     unsigned getBind() const { return (Info >> 4) & 0xf; }
getTypeELFSym143     unsigned getType() const { return Info & 0xf; }
isLocalBindELFSym144     bool isLocalBind() const { return getBind() == ELF::STB_LOCAL; }
isFileTypeELFSym145     bool isFileType() const { return getType() == ELF::STT_FILE; }
146 
setBindELFSym147     void setBind(unsigned X) {
148       assert(X == (X & 0xF) && "Bind value out of range!");
149       Info = (Info & 0x0F) | (X << 4);
150     }
151 
setTypeELFSym152     void setType(unsigned X) {
153       assert(X == (X & 0xF) && "Type value out of range!");
154       Info = (Info & 0xF0) | X;
155     }
156 
setVisibilityELFSym157     void setVisibility(unsigned V) {
158       assert(V == (V & 0x3) && "Visibility value out of range!");
159       Other = V;
160     }
161   };
162 
163   /// ELFSection - This struct contains information about each section that is
164   /// emitted to the file.  This is eventually turned into the section header
165   /// table at the end of the file.
166   class ELFSection : public BinaryObject {
167     public:
168     // ELF specific fields
169     unsigned NameIdx;   // sh_name - .shstrtab idx of name, once emitted.
170     unsigned Type;      // sh_type - Section contents & semantics
171     unsigned Flags;     // sh_flags - Section flags.
172     uint64_t Addr;      // sh_addr - The mem addr this section is in.
173     unsigned Offset;    // sh_offset - Offset from the file start
174     unsigned Size;      // sh_size - The section size.
175     unsigned Link;      // sh_link - Section header table index link.
176     unsigned Info;      // sh_info - Auxiliary information.
177     unsigned Align;     // sh_addralign - Alignment of section.
178     unsigned EntSize;   // sh_entsize - Size of entries in the section e
179 
180     /// SectionIdx - The number of the section in the Section Table.
181     unsigned short SectionIdx;
182 
183     /// Sym - The symbol to represent this section if it has one.
184     ELFSym *Sym;
185 
186     /// getSymIndex - Returns the symbol table index of the symbol
187     /// representing this section.
getSymbolTableIndex()188     unsigned getSymbolTableIndex() const {
189       assert(Sym && "section not present in the symbol table");
190       return Sym->SymTabIdx;
191     }
192 
ELFSection(const std::string & name,bool isLittleEndian,bool is64Bit)193     ELFSection(const std::string &name, bool isLittleEndian, bool is64Bit)
194       : BinaryObject(name, isLittleEndian, is64Bit), Type(0), Flags(0), Addr(0),
195         Offset(0), Size(0), Link(0), Info(0), Align(0), EntSize(0), Sym(0) {}
196   };
197 
198   /// ELFRelocation - This class contains all the information necessary to
199   /// to generate any 32-bit or 64-bit ELF relocation entry.
200   class ELFRelocation {
201     uint64_t r_offset;    // offset in the section of the object this applies to
202     uint32_t r_symidx;    // symbol table index of the symbol to use
203     uint32_t r_type;      // machine specific relocation type
204     int64_t  r_add;       // explicit relocation addend
205     bool     r_rela;      // if true then the addend is part of the entry
206                           // otherwise the addend is at the location specified
207                           // by r_offset
208   public:
getInfo(bool is64Bit)209     uint64_t getInfo(bool is64Bit) const {
210       if (is64Bit)
211         return ((uint64_t)r_symidx << 32) + ((uint64_t)r_type & 0xFFFFFFFFL);
212       else
213         return (r_symidx << 8)  + (r_type & 0xFFL);
214     }
215 
getOffset()216     uint64_t getOffset() const { return r_offset; }
getAddend()217     int64_t getAddend() const { return r_add; }
218 
219     ELFRelocation(uint64_t off, uint32_t sym, uint32_t type,
220                   bool rela = true, int64_t addend = 0) :
r_offset(off)221       r_offset(off), r_symidx(sym), r_type(type),
222       r_add(addend), r_rela(rela) {}
223   };
224 
225 } // end namespace llvm
226 
227 #endif
228