1 //===- MCSymbol.h - Machine Code Symbols ------------------------*- 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 file contains the declaration of the MCSymbol class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_MC_MCSYMBOL_H 15 #define LLVM_MC_MCSYMBOL_H 16 17 #include "llvm/ADT/StringRef.h" 18 19 namespace llvm { 20 class MCExpr; 21 class MCSection; 22 class MCContext; 23 class raw_ostream; 24 25 /// MCSymbol - Instances of this class represent a symbol name in the MC file, 26 /// and MCSymbols are created and unique'd by the MCContext class. MCSymbols 27 /// should only be constructed with valid names for the object file. 28 /// 29 /// If the symbol is defined/emitted into the current translation unit, the 30 /// Section member is set to indicate what section it lives in. Otherwise, if 31 /// it is a reference to an external entity, it has a null section. 32 class MCSymbol { 33 // Special sentinal value for the absolute pseudo section. 34 // 35 // FIXME: Use a PointerInt wrapper for this? 36 static const MCSection *AbsolutePseudoSection; 37 38 /// Name - The name of the symbol. The referred-to string data is actually 39 /// held by the StringMap that lives in MCContext. 40 StringRef Name; 41 42 /// Section - The section the symbol is defined in. This is null for 43 /// undefined symbols, and the special AbsolutePseudoSection value for 44 /// absolute symbols. 45 const MCSection *Section; 46 47 /// Value - If non-null, the value for a variable symbol. 48 const MCExpr *Value; 49 50 /// IsTemporary - True if this is an assembler temporary label, which 51 /// typically does not survive in the .o file's symbol table. Usually 52 /// "Lfoo" or ".foo". 53 unsigned IsTemporary : 1; 54 55 /// IsUsed - True if this symbol has been used. 56 mutable unsigned IsUsed : 1; 57 58 private: // MCContext creates and uniques these. 59 friend class MCExpr; 60 friend class MCContext; MCSymbol(StringRef name,bool isTemporary)61 MCSymbol(StringRef name, bool isTemporary) 62 : Name(name), Section(0), Value(0), 63 IsTemporary(isTemporary), IsUsed(false) {} 64 65 MCSymbol(const MCSymbol&); // DO NOT IMPLEMENT 66 void operator=(const MCSymbol&); // DO NOT IMPLEMENT 67 public: 68 /// getName - Get the symbol name. getName()69 StringRef getName() const { return Name; } 70 71 /// @name Accessors 72 /// @{ 73 74 /// isTemporary - Check if this is an assembler temporary symbol. isTemporary()75 bool isTemporary() const { return IsTemporary; } 76 77 /// isUsed - Check if this is used. isUsed()78 bool isUsed() const { return IsUsed; } setUsed(bool Value)79 void setUsed(bool Value) const { IsUsed = Value; } 80 81 /// @} 82 /// @name Associated Sections 83 /// @{ 84 85 /// isDefined - Check if this symbol is defined (i.e., it has an address). 86 /// 87 /// Defined symbols are either absolute or in some section. isDefined()88 bool isDefined() const { 89 return Section != 0; 90 } 91 92 /// isInSection - Check if this symbol is defined in some section (i.e., it 93 /// is defined but not absolute). isInSection()94 bool isInSection() const { 95 return isDefined() && !isAbsolute(); 96 } 97 98 /// isUndefined - Check if this symbol undefined (i.e., implicitly defined). isUndefined()99 bool isUndefined() const { 100 return !isDefined(); 101 } 102 103 /// isAbsolute - Check if this is an absolute symbol. isAbsolute()104 bool isAbsolute() const { 105 return Section == AbsolutePseudoSection; 106 } 107 108 /// getSection - Get the section associated with a defined, non-absolute 109 /// symbol. getSection()110 const MCSection &getSection() const { 111 assert(isInSection() && "Invalid accessor!"); 112 return *Section; 113 } 114 115 /// setSection - Mark the symbol as defined in the section \arg S. setSection(const MCSection & S)116 void setSection(const MCSection &S) { Section = &S; } 117 118 /// setUndefined - Mark the symbol as undefined. setUndefined()119 void setUndefined() { 120 Section = 0; 121 } 122 123 /// setAbsolute - Mark the symbol as absolute. setAbsolute()124 void setAbsolute() { Section = AbsolutePseudoSection; } 125 126 /// @} 127 /// @name Variable Symbols 128 /// @{ 129 130 /// isVariable - Check if this is a variable symbol. isVariable()131 bool isVariable() const { 132 return Value != 0; 133 } 134 135 /// getValue() - Get the value for variable symbols. getVariableValue()136 const MCExpr *getVariableValue() const { 137 assert(isVariable() && "Invalid accessor!"); 138 IsUsed = true; 139 return Value; 140 } 141 142 // AliasedSymbol() - If this is an alias (a = b), return the symbol 143 // we ultimately point to. For a non alias, this just returns the symbol 144 // itself. 145 const MCSymbol &AliasedSymbol() const; 146 147 void setVariableValue(const MCExpr *Value); 148 149 /// @} 150 151 /// print - Print the value to the stream \arg OS. 152 void print(raw_ostream &OS) const; 153 154 /// dump - Print the value to stderr. 155 void dump() const; 156 }; 157 158 inline raw_ostream &operator<<(raw_ostream &OS, const MCSymbol &Sym) { 159 Sym.print(OS); 160 return OS; 161 } 162 } // end namespace llvm 163 164 #endif 165