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); 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 bool TargetLoweringObjectFile::shouldPutJumpTableInFunctionSection( 279 bool UsesLabelDifference, const Function &F) const { 280 // In PIC mode, we need to emit the jump table to the same section as the 281 // function body itself, otherwise the label differences won't make sense. 282 // FIXME: Need a better predicate for this: what about custom entries? 283 if (UsesLabelDifference) 284 return true; 285 286 // We should also do if the section name is NULL or function is declared 287 // in discardable section 288 // FIXME: this isn't the right predicate, should be based on the MCSection 289 // for the function. 290 if (F.isWeakForLinker()) 291 return true; 292 293 return false; 294 } 295 296 /// getSectionForConstant - Given a mergable constant with the 297 /// specified size and relocation information, return a section that it 298 /// should be placed in. 299 const MCSection * 300 TargetLoweringObjectFile::getSectionForConstant(SectionKind Kind, 301 const Constant *C) const { 302 if (Kind.isReadOnly() && ReadOnlySection != nullptr) 303 return ReadOnlySection; 304 305 return DataSection; 306 } 307 308 /// getTTypeGlobalReference - Return an MCExpr to use for a 309 /// reference to the specified global variable from exception 310 /// handling information. 311 const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference( 312 const GlobalValue *GV, unsigned Encoding, Mangler &Mang, 313 const TargetMachine &TM, MachineModuleInfo *MMI, 314 MCStreamer &Streamer) const { 315 const MCSymbolRefExpr *Ref = 316 MCSymbolRefExpr::Create(TM.getSymbol(GV, Mang), getContext()); 317 318 return getTTypeReference(Ref, Encoding, Streamer); 319 } 320 321 const MCExpr *TargetLoweringObjectFile:: 322 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, 323 MCStreamer &Streamer) const { 324 switch (Encoding & 0x70) { 325 default: 326 report_fatal_error("We do not support this DWARF encoding yet!"); 327 case dwarf::DW_EH_PE_absptr: 328 // Do nothing special 329 return Sym; 330 case dwarf::DW_EH_PE_pcrel: { 331 // Emit a label to the streamer for the current position. This gives us 332 // .-foo addressing. 333 MCSymbol *PCSym = getContext().CreateTempSymbol(); 334 Streamer.EmitLabel(PCSym); 335 const MCExpr *PC = MCSymbolRefExpr::Create(PCSym, getContext()); 336 return MCBinaryExpr::CreateSub(Sym, PC, getContext()); 337 } 338 } 339 } 340 341 const MCExpr *TargetLoweringObjectFile::getDebugThreadLocalSymbol(const MCSymbol *Sym) const { 342 // FIXME: It's not clear what, if any, default this should have - perhaps a 343 // null return could mean 'no location' & we should just do that here. 344 return MCSymbolRefExpr::Create(Sym, *Ctx); 345 } 346 347 void TargetLoweringObjectFile::getNameWithPrefix( 348 SmallVectorImpl<char> &OutName, const GlobalValue *GV, 349 bool CannotUsePrivateLabel, Mangler &Mang, const TargetMachine &TM) const { 350 Mang.getNameWithPrefix(OutName, GV, CannotUsePrivateLabel); 351 } 352