third_party/LLVM/lib/CodeGen/ELF.h - SwiftShader - Git at Google

 //===-- lib/CodeGen/ELF.h - ELF constants and data structures ---*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This header contains common, non-processor-specific data structures and
 // constants for the ELF file format.
 //
 // The details of the ELF32 bits in this file are largely based on the Tool
 // Interface Standard (TIS) Executable and Linking Format (ELF) Specification
 // Version 1.2, May 1995. The ELF64 is based on HP/Intel definition of the
 // ELF-64 object file format document, Version 1.5 Draft 2 May 27, 1998
 //
 //===----------------------------------------------------------------------===//

 #ifndef CODEGEN_ELF_H
 #define CODEGEN_ELF_H

 #include "llvm/CodeGen/BinaryObject.h"
 #include "llvm/CodeGen/MachineRelocation.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/DataTypes.h"

 namespace llvm {
   class GlobalValue;

   /// ELFSym - This struct contains information about each symbol that is
   /// added to logical symbol table for the module.  This is eventually
   /// turned into a real symbol table in the file.
   struct ELFSym {

     // ELF symbols are related to llvm ones by being one of the two llvm
     // types, for the other ones (section, file, func) a null pointer is
     // assumed by default.
     union {
       const GlobalValue *GV;  // If this is a pointer to a GV
       const char *Ext;        // If this is a pointer to a named symbol
     } Source;

     // Describes from which source type this ELF symbol comes from,
     // they can be GlobalValue, ExternalSymbol or neither.
     enum {
       isGV,      // The Source.GV field is valid.
       isExtSym,  // The Source.ExtSym field is valid.
       isOther    // Not a GlobalValue or External Symbol
     };
     unsigned SourceType;

     bool isGlobalValue() const { return SourceType == isGV; }
     bool isExternalSym() const { return SourceType == isExtSym; }

     // getGlobalValue - If this is a global value which originated the
     // elf symbol, return a reference to it.
     const GlobalValue *getGlobalValue() const {
       assert(SourceType == isGV && "This is not a global value");
       return Source.GV;
     }

     // getExternalSym - If this is an external symbol which originated the
     // elf symbol, return a reference to it.
     const char *getExternalSymbol() const {
       assert(SourceType == isExtSym && "This is not an external symbol");
       return Source.Ext;
     }

     // getGV - From a global value return a elf symbol to represent it
     static ELFSym *getGV(const GlobalValue *GV, unsigned Bind,
                          unsigned Type, unsigned Visibility) {
       ELFSym *Sym = new ELFSym();
       Sym->Source.GV = GV;
       Sym->setBind(Bind);
       Sym->setType(Type);
       Sym->setVisibility(Visibility);
       Sym->SourceType = isGV;
       return Sym;
     }

     // getExtSym - Create and return an elf symbol to represent an
     // external symbol
     static ELFSym *getExtSym(const char *Ext) {
       ELFSym *Sym = new ELFSym();
       Sym->Source.Ext = Ext;
       Sym->setBind(ELF::STB_GLOBAL);
       Sym->setType(ELF::STT_NOTYPE);
       Sym->setVisibility(ELF::STV_DEFAULT);
       Sym->SourceType = isExtSym;
       return Sym;
     }

     // getSectionSym - Returns a elf symbol to represent an elf section
     static ELFSym *getSectionSym() {
       ELFSym *Sym = new ELFSym();
       Sym->setBind(ELF::STB_LOCAL);
       Sym->setType(ELF::STT_SECTION);
       Sym->setVisibility(ELF::STV_DEFAULT);
       Sym->SourceType = isOther;
       return Sym;
     }

     // getFileSym - Returns a elf symbol to represent the module identifier
     static ELFSym *getFileSym() {
       ELFSym *Sym = new ELFSym();
       Sym->setBind(ELF::STB_LOCAL);
       Sym->setType(ELF::STT_FILE);
       Sym->setVisibility(ELF::STV_DEFAULT);
       Sym->SectionIdx = 0xfff1;  // ELFSection::SHN_ABS;
       Sym->SourceType = isOther;
       return Sym;
     }

     // getUndefGV - Returns a STT_NOTYPE symbol
     static ELFSym *getUndefGV(const GlobalValue *GV, unsigned Bind) {
       ELFSym *Sym = new ELFSym();
       Sym->Source.GV = GV;
       Sym->setBind(Bind);
       Sym->setType(ELF::STT_NOTYPE);
       Sym->setVisibility(ELF::STV_DEFAULT);
       Sym->SectionIdx = 0;  //ELFSection::SHN_UNDEF;
       Sym->SourceType = isGV;
       return Sym;
     }

     // ELF specific fields
     unsigned NameIdx;         // Index in .strtab of name, once emitted.
     uint64_t Value;
     unsigned Size;
     uint8_t Info;
     uint8_t Other;
     unsigned short SectionIdx;

     // Symbol index into the Symbol table
     unsigned SymTabIdx;

     ELFSym() : SourceType(isOther), NameIdx(0), Value(0),
                Size(0), Info(0), Other(ELF::STV_DEFAULT), SectionIdx(0),
                SymTabIdx(0) {}

     unsigned getBind() const { return (Info >> 4) & 0xf; }
     unsigned getType() const { return Info & 0xf; }
     bool isLocalBind() const { return getBind() == ELF::STB_LOCAL; }
     bool isFileType() const { return getType() == ELF::STT_FILE; }

     void setBind(unsigned X) {
       assert(X == (X & 0xF) && "Bind value out of range!");
       Info = (Info & 0x0F) | (X << 4);
     }

     void setType(unsigned X) {
       assert(X == (X & 0xF) && "Type value out of range!");
       Info = (Info & 0xF0) | X;
     }

     void setVisibility(unsigned V) {
       assert(V == (V & 0x3) && "Visibility value out of range!");
       Other = V;
     }
   };

   /// ELFSection - This struct contains information about each section that is
   /// emitted to the file.  This is eventually turned into the section header
   /// table at the end of the file.
   class ELFSection : public BinaryObject {
     public:
     // ELF specific fields
     unsigned NameIdx;   // sh_name - .shstrtab idx of name, once emitted.
     unsigned Type;      // sh_type - Section contents & semantics
     unsigned Flags;     // sh_flags - Section flags.
     uint64_t Addr;      // sh_addr - The mem addr this section is in.
     unsigned Offset;    // sh_offset - Offset from the file start
     unsigned Size;      // sh_size - The section size.
     unsigned Link;      // sh_link - Section header table index link.
     unsigned Info;      // sh_info - Auxiliary information.
     unsigned Align;     // sh_addralign - Alignment of section.
     unsigned EntSize;   // sh_entsize - Size of entries in the section e

     /// SectionIdx - The number of the section in the Section Table.
     unsigned short SectionIdx;

     /// Sym - The symbol to represent this section if it has one.
     ELFSym *Sym;

     /// getSymIndex - Returns the symbol table index of the symbol
     /// representing this section.
     unsigned getSymbolTableIndex() const {
       assert(Sym && "section not present in the symbol table");
       return Sym->SymTabIdx;
     }

     ELFSection(const std::string &name, bool isLittleEndian, bool is64Bit)
       : BinaryObject(name, isLittleEndian, is64Bit), Type(0), Flags(0), Addr(0),
         Offset(0), Size(0), Link(0), Info(0), Align(0), EntSize(0), Sym(0) {}
   };

   /// ELFRelocation - This class contains all the information necessary to
   /// to generate any 32-bit or 64-bit ELF relocation entry.
   class ELFRelocation {
     uint64_t r_offset;    // offset in the section of the object this applies to
     uint32_t r_symidx;    // symbol table index of the symbol to use
     uint32_t r_type;      // machine specific relocation type
     int64_t  r_add;       // explicit relocation addend
     bool     r_rela;      // if true then the addend is part of the entry
                           // otherwise the addend is at the location specified
                           // by r_offset
   public:
     uint64_t getInfo(bool is64Bit) const {
       if (is64Bit)
         return ((uint64_t)r_symidx << 32) + ((uint64_t)r_type & 0xFFFFFFFFL);
       else
         return (r_symidx << 8)  + (r_type & 0xFFL);
     }

     uint64_t getOffset() const { return r_offset; }
     int64_t getAddend() const { return r_add; }

     ELFRelocation(uint64_t off, uint32_t sym, uint32_t type,
                   bool rela = true, int64_t addend = 0) :
       r_offset(off), r_symidx(sym), r_type(type),
       r_add(addend), r_rela(rela) {}
   };

 } // end namespace llvm

 #endif
	//===-- lib/CodeGen/ELF.h - ELF constants and data structures ---- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	//
	// This header contains common, non-processor-specific data structures and
	// constants for the ELF file format.
	//
	// The details of the ELF32 bits in this file are largely based on the Tool
	// Interface Standard (TIS) Executable and Linking Format (ELF) Specification
	// Version 1.2, May 1995. The ELF64 is based on HP/Intel definition of the
	// ELF-64 object file format document, Version 1.5 Draft 2 May 27, 1998
	//
	//===----------------------------------------------------------------------===//

	#ifndef CODEGEN_ELF_H
	#define CODEGEN_ELF_H

	#include "llvm/CodeGen/BinaryObject.h"
	#include "llvm/CodeGen/MachineRelocation.h"
	#include "llvm/Support/ELF.h"
	#include "llvm/Support/DataTypes.h"

	namespace llvm {
	class GlobalValue;

	/// ELFSym - This struct contains information about each symbol that is
	/// added to logical symbol table for the module. This is eventually
	/// turned into a real symbol table in the file.
	struct ELFSym {

	// ELF symbols are related to llvm ones by being one of the two llvm
	// types, for the other ones (section, file, func) a null pointer is
	// assumed by default.
	union {
	const GlobalValue *GV; // If this is a pointer to a GV
	const char *Ext; // If this is a pointer to a named symbol
	} Source;

	// Describes from which source type this ELF symbol comes from,
	// they can be GlobalValue, ExternalSymbol or neither.
	enum {
	isGV, // The Source.GV field is valid.
	isExtSym, // The Source.ExtSym field is valid.
	isOther // Not a GlobalValue or External Symbol
	};
	unsigned SourceType;

	bool isGlobalValue() const { return SourceType == isGV; }
	bool isExternalSym() const { return SourceType == isExtSym; }

	// getGlobalValue - If this is a global value which originated the
	// elf symbol, return a reference to it.
	const GlobalValue *getGlobalValue() const {
	assert(SourceType == isGV && "This is not a global value");
	return Source.GV;
	}

	// getExternalSym - If this is an external symbol which originated the
	// elf symbol, return a reference to it.
	const char *getExternalSymbol() const {
	assert(SourceType == isExtSym && "This is not an external symbol");
	return Source.Ext;
	}

	// getGV - From a global value return a elf symbol to represent it
	static ELFSym getGV(const GlobalValue GV, unsigned Bind,
	unsigned Type, unsigned Visibility) {
	ELFSym *Sym = new ELFSym();
	Sym->Source.GV = GV;
	Sym->setBind(Bind);
	Sym->setType(Type);
	Sym->setVisibility(Visibility);
	Sym->SourceType = isGV;
	return Sym;
	}

	// getExtSym - Create and return an elf symbol to represent an
	// external symbol
	static ELFSym getExtSym(const char Ext) {
	ELFSym *Sym = new ELFSym();
	Sym->Source.Ext = Ext;
	Sym->setBind(ELF::STB_GLOBAL);
	Sym->setType(ELF::STT_NOTYPE);
	Sym->setVisibility(ELF::STV_DEFAULT);
	Sym->SourceType = isExtSym;
	return Sym;
	}

	// getSectionSym - Returns a elf symbol to represent an elf section
	static ELFSym *getSectionSym() {
	ELFSym *Sym = new ELFSym();
	Sym->setBind(ELF::STB_LOCAL);
	Sym->setType(ELF::STT_SECTION);
	Sym->setVisibility(ELF::STV_DEFAULT);
	Sym->SourceType = isOther;
	return Sym;
	}

	// getFileSym - Returns a elf symbol to represent the module identifier
	static ELFSym *getFileSym() {
	ELFSym *Sym = new ELFSym();
	Sym->setBind(ELF::STB_LOCAL);
	Sym->setType(ELF::STT_FILE);
	Sym->setVisibility(ELF::STV_DEFAULT);
	Sym->SectionIdx = 0xfff1; // ELFSection::SHN_ABS;
	Sym->SourceType = isOther;
	return Sym;
	}

	// getUndefGV - Returns a STT_NOTYPE symbol
	static ELFSym getUndefGV(const GlobalValue GV, unsigned Bind) {
	ELFSym *Sym = new ELFSym();
	Sym->Source.GV = GV;
	Sym->setBind(Bind);
	Sym->setType(ELF::STT_NOTYPE);
	Sym->setVisibility(ELF::STV_DEFAULT);
	Sym->SectionIdx = 0; //ELFSection::SHN_UNDEF;
	Sym->SourceType = isGV;
	return Sym;
	}

	// ELF specific fields
	unsigned NameIdx; // Index in .strtab of name, once emitted.
	uint64_t Value;
	unsigned Size;
	uint8_t Info;
	uint8_t Other;
	unsigned short SectionIdx;

	// Symbol index into the Symbol table
	unsigned SymTabIdx;

	ELFSym() : SourceType(isOther), NameIdx(0), Value(0),
	Size(0), Info(0), Other(ELF::STV_DEFAULT), SectionIdx(0),
	SymTabIdx(0) {}

	unsigned getBind() const { return (Info >> 4) & 0xf; }
	unsigned getType() const { return Info & 0xf; }
	bool isLocalBind() const { return getBind() == ELF::STB_LOCAL; }
	bool isFileType() const { return getType() == ELF::STT_FILE; }

	void setBind(unsigned X) {
	assert(X == (X & 0xF) && "Bind value out of range!");
	Info = (Info & 0x0F) \| (X << 4);
	}

	void setType(unsigned X) {
	assert(X == (X & 0xF) && "Type value out of range!");
	Info = (Info & 0xF0) \| X;
	}

	void setVisibility(unsigned V) {
	assert(V == (V & 0x3) && "Visibility value out of range!");
	Other = V;
	}
	};

	/// ELFSection - This struct contains information about each section that is
	/// emitted to the file. This is eventually turned into the section header
	/// table at the end of the file.
	class ELFSection : public BinaryObject {
	public:
	// ELF specific fields
	unsigned NameIdx; // sh_name - .shstrtab idx of name, once emitted.
	unsigned Type; // sh_type - Section contents & semantics
	unsigned Flags; // sh_flags - Section flags.
	uint64_t Addr; // sh_addr - The mem addr this section is in.
	unsigned Offset; // sh_offset - Offset from the file start
	unsigned Size; // sh_size - The section size.
	unsigned Link; // sh_link - Section header table index link.
	unsigned Info; // sh_info - Auxiliary information.
	unsigned Align; // sh_addralign - Alignment of section.
	unsigned EntSize; // sh_entsize - Size of entries in the section e

	/// SectionIdx - The number of the section in the Section Table.
	unsigned short SectionIdx;

	/// Sym - The symbol to represent this section if it has one.
	ELFSym *Sym;

	/// getSymIndex - Returns the symbol table index of the symbol
	/// representing this section.
	unsigned getSymbolTableIndex() const {
	assert(Sym && "section not present in the symbol table");
	return Sym->SymTabIdx;
	}

	ELFSection(const std::string &name, bool isLittleEndian, bool is64Bit)
	: BinaryObject(name, isLittleEndian, is64Bit), Type(0), Flags(0), Addr(0),
	Offset(0), Size(0), Link(0), Info(0), Align(0), EntSize(0), Sym(0) {}
	};

	/// ELFRelocation - This class contains all the information necessary to
	/// to generate any 32-bit or 64-bit ELF relocation entry.
	class ELFRelocation {
	uint64_t r_offset; // offset in the section of the object this applies to
	uint32_t r_symidx; // symbol table index of the symbol to use
	uint32_t r_type; // machine specific relocation type
	int64_t r_add; // explicit relocation addend
	bool r_rela; // if true then the addend is part of the entry
	// otherwise the addend is at the location specified
	// by r_offset
	public:
	uint64_t getInfo(bool is64Bit) const {
	if (is64Bit)
	return ((uint64_t)r_symidx << 32) + ((uint64_t)r_type & 0xFFFFFFFFL);
	else
	return (r_symidx << 8) + (r_type & 0xFFL);
	}

	uint64_t getOffset() const { return r_offset; }
	int64_t getAddend() const { return r_add; }

	ELFRelocation(uint64_t off, uint32_t sym, uint32_t type,
	bool rela = true, int64_t addend = 0) :
	r_offset(off), r_symidx(sym), r_type(type),
	r_add(addend), r_rela(rela) {}
	};

	} // end namespace llvm

	#endif