#ifndef LLVM_TARGET_ASM_INFO_H
#define LLVM_TARGET_ASM_INFO_H
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/StringMap.h"
#include "llvm/Support/DataTypes.h"
+#include <cassert>
#include <string>
namespace llvm {
- // DWARF encoding query type
- namespace DwarfEncoding {
- enum Target {
- Data = 0,
- CodeLabels = 1,
- Functions = 2
- };
- }
-
- /// SectionKind - This is a simple POD value that classifies the properties of
- /// a section. A global variable is classified into the deepest possible
- /// classification, and then the target maps them onto their sections based on
- /// what capabilities they have.
- ///
- /// The comments below describe these as if they were an inheritance hierarchy
- /// in order to explain the predicates below.
- struct SectionKind {
- enum Kind {
- /// Text - Text section, used for functions and other executable code.
- Text,
-
- /// ReadOnly - Data that is never written to at program runtime by the
- /// program or the dynamic linker. Things in the top-level readonly
- /// SectionKind are not mergeable.
- ReadOnly,
-
- /// MergeableCString - This is a special section for nul-terminated
- /// strings. The linker can unique the C strings, knowing their
- /// semantics. Because it uniques based on the nul terminators, the
- /// compiler can't put strings in this section that have embeded nuls
- /// in them.
- MergeableCString,
-
- /// MergeableConst - These are sections for merging fixed-length
- /// constants together. For example, this can be used to unique
- /// constant pool entries etc.
- MergeableConst,
-
- /// MergeableConst4 - This is a section used by 4-byte constants,
- /// for example, floats.
- MergeableConst4,
-
- /// MergeableConst8 - This is a section used by 8-byte constants,
- /// for example, doubles.
- MergeableConst8,
-
- /// MergeableConst16 - This is a section used by 16-byte constants,
- /// for example, vectors.
- MergeableConst16,
-
- /// Writeable - This is the base of all segments that need to be written
- /// to during program runtime.
-
- /// ThreadLocal - This is the base of all TLS segments. All TLS
- /// objects must be writeable, otherwise there is no reason for them to
- /// be thread local!
-
- /// ThreadBSS - Zero-initialized TLS data objects.
- ThreadBSS,
-
- /// ThreadData - Initialized TLS data objects.
- ThreadData,
-
- /// GlobalWriteableData - Writeable data that is global (not thread
- /// local).
-
- /// BSS - Zero initialized writeable data.
- BSS,
-
- /// DataRel - This is the most general form of data that is written
- /// to by the program, it can have random relocations to arbitrary
- /// globals.
- DataRel,
-
- /// DataRelLocal - This is writeable data that has a non-zero
- /// initializer and has relocations in it, but all of the
- /// relocations are known to be within the final linked image
- /// the global is linked into.
- DataRelLocal,
-
- /// DataNoRel - This is writeable data that has a non-zero
- /// initializer, but whose initializer is known to have no
- /// relocations.
- DataNoRel,
-
- /// ReadOnlyWithRel - These are global variables that are never
- /// written to by the program, but that have relocations, so they
- /// must be stuck in a writeable section so that the dynamic linker
- /// can write to them. If it chooses to, the dynamic linker can
- /// mark the pages these globals end up on as read-only after it is
- /// done with its relocation phase.
- ReadOnlyWithRel,
-
- /// ReadOnlyWithRelLocal - This is data that is readonly by the
- /// program, but must be writeable so that the dynamic linker
- /// can perform relocations in it. This is used when we know
- /// that all the relocations are to globals in this final
- /// linked image.
- ReadOnlyWithRelLocal
-
- };
-
- private:
- Kind K : 6;
-
- /// Weak - This is true if the referenced symbol is weak (i.e. linkonce,
- /// weak, weak_odr, etc). This is orthogonal from the categorization.
- bool Weak : 1;
-
- /// ExplicitSection - This is true if the global had a section explicitly
- /// specified on it.
- bool ExplicitSection : 1;
- public:
-
- bool isWeak() const { return Weak; }
- bool hasExplicitSection() const { return ExplicitSection; }
-
- bool isText() const { return K == Text; }
-
- bool isReadOnly() const {
- return K == ReadOnly || K == MergeableCString || isMergeableConst();
- }
-
- bool isMergeableCString() const { return K == MergeableCString; }
- bool isMergeableConst() const {
- return K == MergeableConst || K == MergeableConst4 ||
- K == MergeableConst8 || K == MergeableConst16;
- }
-
- bool isMergeableConst4() const { return K == MergeableConst4; }
- bool isMergeableConst8() const { return K == MergeableConst8; }
- bool isMergeableConst16() const { return K == MergeableConst16; }
-
- bool isWriteable() const {
- return isThreadLocal() || isGlobalWriteableData();
- }
-
- bool isThreadLocal() const {
- return K == ThreadData || K == ThreadBSS;
- }
-
- bool isThreadBSS() const { return K == ThreadBSS; }
- bool isThreadData() const { return K == ThreadData; }
-
- bool isGlobalWriteableData() const {
- return isBSS() || isDataRel() || isReadOnlyWithRel();
- }
-
- bool isBSS() const { return K == BSS; }
-
- bool isDataRel() const {
- return K == DataRel || K == DataRelLocal || K == DataNoRel;
- }
-
- bool isDataRelLocal() const {
- return K == DataRelLocal || K == DataNoRel;
- }
-
- bool isDataNoRel() const { return K == DataNoRel; }
-
- bool isReadOnlyWithRel() const {
- return K == ReadOnlyWithRel || K == ReadOnlyWithRelLocal;
- }
-
- bool isReadOnlyWithRelLocal() const {
- return K == ReadOnlyWithRelLocal;
- }
-
- static SectionKind get(Kind K, bool isWeak,
- bool hasExplicitSection = false) {
- SectionKind Res;
- Res.K = K;
- Res.Weak = isWeak;
- Res.ExplicitSection = hasExplicitSection;
- return Res;
- }
- };
-
- namespace SectionFlags {
- const unsigned Invalid = -1U;
- const unsigned None = 0;
- const unsigned Code = 1 << 0; ///< Section contains code
- const unsigned Writable = 1 << 1; ///< Section is writeable
- const unsigned BSS = 1 << 2; ///< Section contains only zeroes
- const unsigned Mergeable = 1 << 3; ///< Section contains mergeable data
- const unsigned Strings = 1 << 4; ///< Section contains C-type strings
- const unsigned TLS = 1 << 5; ///< Section contains thread-local data
- const unsigned Debug = 1 << 6; ///< Section contains debug data
- const unsigned Linkonce = 1 << 7; ///< Section is linkonce
- const unsigned TypeFlags = 0xFF;
- // Some gap for future flags
-
- /// Named - True if this section should be printed with ".section <name>",
- /// false if the section name is something like ".const".
- const unsigned Named = 1 << 23; ///< Section is named
- const unsigned EntitySize = 0xFF << 24; ///< Entity size for mergeable stuff
-
- static inline unsigned getEntitySize(unsigned Flags) {
- return (Flags >> 24) & 0xFF;
- }
-
- // FIXME: Why does this return a value?
- static inline unsigned setEntitySize(unsigned Flags, unsigned Size) {
- return (Flags & ~EntitySize) | ((Size & 0xFF) << 24);
- }
-
- struct KeyInfo {
- static inline unsigned getEmptyKey() { return Invalid; }
- static inline unsigned getTombstoneKey() { return Invalid - 1; }
- static unsigned getHashValue(const unsigned &Key) { return Key; }
- static bool isEqual(unsigned LHS, unsigned RHS) { return LHS == RHS; }
- static bool isPod() { return true; }
- };
-
- typedef DenseMap<unsigned, std::string, KeyInfo> FlagsStringsMapType;
- }
-
+ template <typename T> class SmallVectorImpl;
class TargetMachine;
- class CallInst;
- class GlobalValue;
- class Type;
- class Mangler;
-
- class Section {
- friend class TargetAsmInfo;
- friend class StringMapEntry<Section>;
- friend class StringMap<Section>;
-
- std::string Name;
- unsigned Flags;
- explicit Section(unsigned F = SectionFlags::Invalid) : Flags(F) { }
-
- public:
-
- unsigned getEntitySize() const { return (Flags >> 24) & 0xFF; }
-
- const std::string &getName() const { return Name; }
- unsigned getFlags() const { return Flags; }
-
- bool hasFlag(unsigned F) const { return (Flags & F) != 0; }
- };
-
+
/// TargetAsmInfo - This class is intended to be used as a base class for asm
/// properties and features specific to the target.
class TargetAsmInfo {
- private:
- mutable StringMap<Section> Sections;
- mutable SectionFlags::FlagsStringsMapType FlagsStrings;
protected:
/// TM - The current TargetMachine.
const TargetMachine &TM;
// Properties to be set by the target writer, used to configure asm printer.
//
- /// TextSection - Section directive for standard text.
- ///
- const Section *TextSection; // Defaults to ".text".
-
- /// DataSection - Section directive for standard data.
- ///
- const Section *DataSection; // Defaults to ".data".
-
- /// BSSSection - Section directive for uninitialized data. Null if this
- /// target doesn't support a BSS section.
- ///
- const char *BSSSection; // Default to ".bss".
- const Section *BSSSection_;
-
- /// ReadOnlySection - This is the directive that is emitted to switch to a
- /// read-only section for constant data (e.g. data declared const,
- /// jump tables).
- const Section *ReadOnlySection; // Defaults to NULL
-
- /// TLSDataSection - Section directive for Thread Local data.
- ///
- const Section *TLSDataSection; // Defaults to ".tdata".
-
- /// TLSBSSSection - Section directive for Thread Local uninitialized data.
- /// Null if this target doesn't support a BSS section.
- ///
- const Section *TLSBSSSection; // Defaults to ".tbss".
-
/// ZeroFillDirective - Directive for emitting a global to the ZeroFill
/// section on this target. Null if this target doesn't support zerofill.
const char *ZeroFillDirective; // Default is null.
/// section with the section name and this suffix printed.
const char *SectionEndDirectiveSuffix;// Defaults to null.
- /// ConstantPoolSection - This is the section that we SwitchToSection right
- /// before emitting the constant pool for a function.
- const char *ConstantPoolSection; // Defaults to "\t.section .rodata"
-
- /// JumpTableDataSection - This is the section that we SwitchToSection right
- /// before emitting the jump tables for a function when the relocation model
- /// is not PIC.
- const char *JumpTableDataSection; // Defaults to "\t.section .rodata"
-
/// JumpTableDirective - if non-null, the directive to emit before a jump
/// table.
const char *JumpTableDirective;
- /// CStringSection - If not null, this allows for special handling of
- /// cstring constants (null terminated string that does not contain any
- /// other null bytes) on this target. This is commonly supported as
- /// ".cstring".
- const char *CStringSection; // Defaults to NULL
- const Section *CStringSection_;
-
- /// StaticCtorsSection - This is the directive that is emitted to switch to
- /// a section to emit the static constructor list.
- /// Defaults to "\t.section .ctors,\"aw\",@progbits".
- const char *StaticCtorsSection;
-
- /// StaticDtorsSection - This is the directive that is emitted to switch to
- /// a section to emit the static destructor list.
- /// Defaults to "\t.section .dtors,\"aw\",@progbits".
- const char *StaticDtorsSection;
-
//===--- Global Variable Emission Directives --------------------------===//
/// GlobalDirective - This is the directive used to declare a global entity.
explicit TargetAsmInfo(const TargetMachine &TM);
virtual ~TargetAsmInfo();
- const Section* getNamedSection(const char *Name,
- unsigned Flags = SectionFlags::None,
- bool Override = false) const;
- const Section* getUnnamedSection(const char *Directive,
- unsigned Flags = SectionFlags::None,
- bool Override = false) const;
-
/// Measure the specified inline asm to determine an approximation of its
/// length.
virtual unsigned getInlineAsmLength(const char *Str) const;
- /// emitUsedDirectiveFor - This hook allows targets to selectively decide
- /// not to emit the UsedDirective for some symbols in llvm.used.
-// FIXME: REMOVE this (rdar://7071300)
- virtual bool emitUsedDirectiveFor(const GlobalValue *GV,
- Mangler *Mang) const {
- return (GV!=0);
- }
-
/// PreferredEHDataFormat - This hook allows the target to select data
- /// format used for encoding pointers in exception handling data. Reason is
- /// 0 for data, 1 for code labels, 2 for function pointers. Global is true
- /// if the symbol can be relocated.
- virtual unsigned PreferredEHDataFormat(DwarfEncoding::Target Reason,
- bool Global) const;
+ /// format used for encoding pointers in exception handling data.
+ virtual unsigned PreferredEHDataFormat() const;
-
- /// getSectionForMergeableConstant - Given a Mergeable constant with the
- /// specified size and relocation information, return a section that it
- /// should be placed in.
- virtual const Section *getSectionForMergeableConstant(SectionKind Kind)const;
-
-
- /// getSectionPrefixForUniqueGlobal - Return a string that we should prepend
- /// onto a global's name in order to get the unique section name for the
- /// global. This is important for globals that need to be merged across
- /// translation units.
- virtual const char *
- getSectionPrefixForUniqueGlobal(SectionKind Kind) const {
- return 0;
- }
-
- /// getFlagsForNamedSection - If this target wants to be able to infer
- /// section flags based on the name of the section specified for a global
- /// variable, it can implement this. This is used on ELF systems so that
- /// ".tbss" gets the TLS bit set etc.
- virtual unsigned getFlagsForNamedSection(const char *Section) const {
- return 0;
- }
-
- /// SectionForGlobal - This method computes the appropriate section to emit
- /// the specified global variable or function definition. This should not
- /// be passed external (or available externally) globals.
- // FIXME: MOVE TO ASMPRINTER.
- const Section* SectionForGlobal(const GlobalValue *GV) const;
-
- /// getSpecialCasedSectionGlobals - Allow the target to completely override
- /// section assignment of a global.
- /// FIXME: ELIMINATE this by making PIC16 implement ADDRESS with
- /// getFlagsForNamedSection.
- virtual const Section *
- getSpecialCasedSectionGlobals(const GlobalValue *GV,
- SectionKind Kind) const {
- return 0;
- }
-
- const std::string &getSectionFlags(unsigned Flags) const;
- virtual std::string printSectionFlags(unsigned flags) const { return ""; }
-
-// FIXME: Eliminate this.
- virtual const Section* SelectSectionForGlobal(const GlobalValue *GV,
- SectionKind Kind) const;
/// getSLEB128Size - Compute the number of bytes required for a signed
/// leb128 value.
// Accessors.
//
- const Section *getTextSection() const {
- return TextSection;
- }
- const Section *getDataSection() const {
- return DataSection;
- }
- const char *getBSSSection() const {
- return BSSSection;
- }
- const Section *getBSSSection_() const {
- return BSSSection_;
- }
- const Section *getReadOnlySection() const {
- return ReadOnlySection;
- }
- const Section *getTLSDataSection() const {
- return TLSDataSection;
- }
- const Section *getTLSBSSSection() const {
- return TLSBSSSection;
- }
const char *getZeroFillDirective() const {
return ZeroFillDirective;
}
const char *getSectionEndDirectiveSuffix() const {
return SectionEndDirectiveSuffix;
}
- const char *getConstantPoolSection() const {
- return ConstantPoolSection;
- }
- const char *getJumpTableDataSection() const {
- return JumpTableDataSection;
- }
- const char *getCStringSection() const {
- return CStringSection;
- }
- const Section *getCStringSection_() const {
- return CStringSection_;
- }
- const char *getStaticCtorsSection() const {
- return StaticCtorsSection;
- }
- const char *getStaticDtorsSection() const {
- return StaticDtorsSection;
- }
const char *getGlobalDirective() const {
return GlobalDirective;
}