1 //===-- llvm/Target/TargetLoweringObjectFile.cpp - Object File Info -------===// 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 implements classes used to handle lowerings specific to common 11 // object file formats. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Target/TargetLoweringObjectFile.h" 16 #include "llvm/IR/Constants.h" 17 #include "llvm/IR/DataLayout.h" 18 #include "llvm/IR/DerivedTypes.h" 19 #include "llvm/IR/Function.h" 20 #include "llvm/IR/GlobalVariable.h" 21 #include "llvm/IR/Mangler.h" 22 #include "llvm/MC/MCAsmInfo.h" 23 #include "llvm/MC/MCContext.h" 24 #include "llvm/MC/MCExpr.h" 25 #include "llvm/MC/MCStreamer.h" 26 #include "llvm/MC/MCSymbol.h" 27 #include "llvm/Support/Dwarf.h" 28 #include "llvm/Support/ErrorHandling.h" 29 #include "llvm/Support/raw_ostream.h" 30 #include "llvm/Target/TargetLowering.h" 31 #include "llvm/Target/TargetMachine.h" 32 #include "llvm/Target/TargetOptions.h" 33 #include "llvm/Target/TargetSubtargetInfo.h" 34 using namespace llvm; 35 36 //===----------------------------------------------------------------------===// 37 // Generic Code 38 //===----------------------------------------------------------------------===// 39 40 /// Initialize - this method must be called before any actual lowering is 41 /// done. This specifies the current context for codegen, and gives the 42 /// lowering implementations a chance to set up their default sections. 43 void TargetLoweringObjectFile::Initialize(MCContext &ctx, 44 const TargetMachine &TM) { 45 Ctx = &ctx; 46 DL = TM.getDataLayout(); 47 InitMCObjectFileInfo(TM.getTargetTriple(), 48 TM.getRelocationModel(), TM.getCodeModel(), *Ctx); 49 } 50 51 TargetLoweringObjectFile::~TargetLoweringObjectFile() { 52 } 53 54 static bool isSuitableForBSS(const GlobalVariable *GV, bool NoZerosInBSS) { 55 const Constant *C = GV->getInitializer(); 56 57 // Must have zero initializer. 58 if (!C->isNullValue()) 59 return false; 60 61 // Leave constant zeros in readonly constant sections, so they can be shared. 62 if (GV->isConstant()) 63 return false; 64 65 // If the global has an explicit section specified, don't put it in BSS. 66 if (GV->hasSection()) 67 return false; 68 69 // If -nozero-initialized-in-bss is specified, don't ever use BSS. 70 if (NoZerosInBSS) 71 return false; 72 73 // Otherwise, put it in BSS! 74 return true; 75 } 76 77 /// IsNullTerminatedString - Return true if the specified constant (which is 78 /// known to have a type that is an array of 1/2/4 byte elements) ends with a 79 /// nul value and contains no other nuls in it. Note that this is more general 80 /// than ConstantDataSequential::isString because we allow 2 & 4 byte strings. 81 static bool IsNullTerminatedString(const Constant *C) { 82 // First check: is we have constant array terminated with zero 83 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) { 84 unsigned NumElts = CDS->getNumElements(); 85 assert(NumElts != 0 && "Can't have an empty CDS"); 86 87 if (CDS->getElementAsInteger(NumElts-1) != 0) 88 return false; // Not null terminated. 89 90 // Verify that the null doesn't occur anywhere else in the string. 91 for (unsigned i = 0; i != NumElts-1; ++i) 92 if (CDS->getElementAsInteger(i) == 0) 93 return false; 94 return true; 95 } 96 97 // Another possibility: [1 x i8] zeroinitializer 98 if (isa<ConstantAggregateZero>(C)) 99 return cast<ArrayType>(C->getType())->getNumElements() == 1; 100 101 return false; 102 } 103 104 MCSymbol *TargetLoweringObjectFile::getSymbolWithGlobalValueBase( 105 const GlobalValue *GV, StringRef Suffix, Mangler &Mang, 106 const TargetMachine &TM) const { 107 assert(!Suffix.empty()); 108 109 SmallString<60> NameStr; 110 NameStr += DL->getPrivateGlobalPrefix(); 111 TM.getNameWithPrefix(NameStr, GV, Mang); 112 NameStr.append(Suffix.begin(), Suffix.end()); 113 return Ctx->GetOrCreateSymbol(NameStr.str()); 114 } 115 116 MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol( 117 const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM, 118 MachineModuleInfo *MMI) const { 119 return TM.getSymbol(GV, Mang); 120 } 121 122 void TargetLoweringObjectFile::emitPersonalityValue(MCStreamer &Streamer, 123 const TargetMachine &TM, 124 const MCSymbol *Sym) const { 125 } 126 127 128 /// getKindForGlobal - This is a top-level target-independent classifier for 129 /// a global variable. Given an global variable and information from TM, it 130 /// classifies the global in a variety of ways that make various target 131 /// implementations simpler. The target implementation is free to ignore this 132 /// extra info of course. 133 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalValue *GV, 134 const TargetMachine &TM){ 135 assert(!GV->isDeclaration() && !GV->hasAvailableExternallyLinkage() && 136 "Can only be used for global definitions"); 137 138 Reloc::Model ReloModel = TM.getRelocationModel(); 139 140 // Early exit - functions should be always in text sections. 141 const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV); 142 if (!GVar) 143 return SectionKind::getText(); 144 145 // Handle thread-local data first. 146 if (GVar->isThreadLocal()) { 147 if (isSuitableForBSS(GVar, TM.Options.NoZerosInBSS)) 148 return SectionKind::getThreadBSS(); 149 return SectionKind::getThreadData(); 150 } 151 152 // Variables with common linkage always get classified as common. 153 if (GVar->hasCommonLinkage()) 154 return SectionKind::getCommon(); 155 156 // Variable can be easily put to BSS section. 157 if (isSuitableForBSS(GVar, TM.Options.NoZerosInBSS)) { 158 if (GVar->hasLocalLinkage()) 159 return SectionKind::getBSSLocal(); 160 else if (GVar->hasExternalLinkage()) 161 return SectionKind::getBSSExtern(); 162 return SectionKind::getBSS(); 163 } 164 165 const Constant *C = GVar->getInitializer(); 166 167 // If the global is marked constant, we can put it into a mergable section, 168 // a mergable string section, or general .data if it contains relocations. 169 if (GVar->isConstant()) { 170 // If the initializer for the global contains something that requires a 171 // relocation, then we may have to drop this into a writable data section 172 // even though it is marked const. 173 switch (C->getRelocationInfo()) { 174 case Constant::NoRelocation: 175 // If the global is required to have a unique address, it can't be put 176 // into a mergable section: just drop it into the general read-only 177 // section instead. 178 if (!GVar->hasUnnamedAddr()) 179 return SectionKind::getReadOnly(); 180 181 // If initializer is a null-terminated string, put it in a "cstring" 182 // section of the right width. 183 if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) { 184 if (IntegerType *ITy = 185 dyn_cast<IntegerType>(ATy->getElementType())) { 186 if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 || 187 ITy->getBitWidth() == 32) && 188 IsNullTerminatedString(C)) { 189 if (ITy->getBitWidth() == 8) 190 return SectionKind::getMergeable1ByteCString(); 191 if (ITy->getBitWidth() == 16) 192 return SectionKind::getMergeable2ByteCString(); 193 194 assert(ITy->getBitWidth() == 32 && "Unknown width"); 195 return SectionKind::getMergeable4ByteCString(); 196 } 197 } 198 } 199 200 // Otherwise, just drop it into a mergable constant section. If we have 201 // a section for this size, use it, otherwise use the arbitrary sized 202 // mergable section. 203 switch (TM.getDataLayout()->getTypeAllocSize(C->getType())) { 204 case 4: return SectionKind::getMergeableConst4(); 205 case 8: return SectionKind::getMergeableConst8(); 206 case 16: return SectionKind::getMergeableConst16(); 207 default: 208 return SectionKind::getReadOnly(); 209 } 210 211 case Constant::LocalRelocation: 212 // In static relocation model, the linker will resolve all addresses, so 213 // the relocation entries will actually be constants by the time the app 214 // starts up. However, we can't put this into a mergable section, because 215 // the linker doesn't take relocations into consideration when it tries to 216 // merge entries in the section. 217 if (ReloModel == Reloc::Static) 218 return SectionKind::getReadOnly(); 219 220 // Otherwise, the dynamic linker needs to fix it up, put it in the 221 // writable data.rel.local section. 222 return SectionKind::getReadOnlyWithRelLocal(); 223 224 case Constant::GlobalRelocations: 225 // In static relocation model, the linker will resolve all addresses, so 226 // the relocation entries will actually be constants by the time the app 227 // starts up. However, we can't put this into a mergable section, because 228 // the linker doesn't take relocations into consideration when it tries to 229 // merge entries in the section. 230 if (ReloModel == Reloc::Static) 231 return SectionKind::getReadOnly(); 232 233 // Otherwise, the dynamic linker needs to fix it up, put it in the 234 // writable data.rel section. 235 return SectionKind::getReadOnlyWithRel(); 236 } 237 } 238 239 // Okay, this isn't a constant. If the initializer for the global is going 240 // to require a runtime relocation by the dynamic linker, put it into a more 241 // specific section to improve startup time of the app. This coalesces these 242 // globals together onto fewer pages, improving the locality of the dynamic 243 // linker. 244 if (ReloModel == Reloc::Static) 245 return SectionKind::getDataNoRel(); 246 247 switch (C->getRelocationInfo()) { 248 case Constant::NoRelocation: 249 return SectionKind::getDataNoRel(); 250 case Constant::LocalRelocation: 251 return SectionKind::getDataRelLocal(); 252 case Constant::GlobalRelocations: 253 return SectionKind::getDataRel(); 254 } 255 llvm_unreachable("Invalid relocation"); 256 } 257 258 /// SectionForGlobal - This method computes the appropriate section to emit 259 /// the specified global variable or function definition. This should not 260 /// be passed external (or available externally) globals. 261 const MCSection *TargetLoweringObjectFile:: 262 SectionForGlobal(const GlobalValue *GV, SectionKind Kind, Mangler &Mang, 263 const TargetMachine &TM) const { 264 // Select section name. 265 if (GV->hasSection()) 266 return getExplicitSectionGlobal(GV, Kind, Mang, TM); 267 268 269 // Use default section depending on the 'type' of global 270 return SelectSectionForGlobal(GV, Kind, Mang, TM); 271 } 272 273 const MCSection *TargetLoweringObjectFile::getSectionForJumpTable( 274 const Function &F, Mangler &Mang, const TargetMachine &TM) const { 275 return getSectionForConstant(SectionKind::getReadOnly(), /*C=*/nullptr); 276 } 277 278 /// getSectionForConstant - Given a mergable constant with the 279 /// specified size and relocation information, return a section that it 280 /// should be placed in. 281 const MCSection * 282 TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind, 283 const Constant *C) const { 284 if (Kind.isReadOnly() && ReadOnlySection != nullptr) 285 return ReadOnlySection; 286 287 return DataSection; 288 } 289 290 /// getTTypeGlobalReference - Return an MCExpr to use for a 291 /// reference to the specified global variable from exception 292 /// handling information. 293 const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference( 294 const GlobalValue *GV, unsigned Encoding, Mangler &Mang, 295 const TargetMachine &TM, MachineModuleInfo *MMI, 296 MCStreamer &Streamer) const { 297 const MCSymbolRefExpr *Ref = 298 MCSymbolRefExpr::Create(TM.getSymbol(GV, Mang), getContext()); 299 300 return getTTypeReference(Ref, Encoding, Streamer); 301 } 302 303 const MCExpr *TargetLoweringObjectFile:: 304 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, 305 MCStreamer &Streamer) const { 306 switch (Encoding & 0x70) { 307 default: 308 report_fatal_error("We do not support this DWARF encoding yet!"); 309 case dwarf::DW_EH_PE_absptr: 310 // Do nothing special 311 return Sym; 312 case dwarf::DW_EH_PE_pcrel: { 313 // Emit a label to the streamer for the current position. This gives us 314 // .-foo addressing. 315 MCSymbol *PCSym = getContext().CreateTempSymbol(); 316 Streamer.EmitLabel(PCSym); 317 const MCExpr *PC = MCSymbolRefExpr::Create(PCSym, getContext()); 318 return MCBinaryExpr::CreateSub(Sym, PC, getContext()); 319 } 320 } 321 } 322 323 const MCExpr *TargetLoweringObjectFile::getDebugThreadLocalSymbol(const MCSymbol *Sym) const { 324 // FIXME: It's not clear what, if any, default this should have - perhaps a 325 // null return could mean 'no location' & we should just do that here. 326 return MCSymbolRefExpr::Create(Sym, *Ctx); 327 } 328