1 //===-- llvm/Target/TargetLoweringObjectFile.cpp - Object File Info -------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements classes used to handle lowerings specific to common 10 // object file formats. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Target/TargetLoweringObjectFile.h" 15 #include "llvm/BinaryFormat/Dwarf.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/IR/Module.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/MC/MCContext.h" 25 #include "llvm/MC/MCExpr.h" 26 #include "llvm/MC/MCStreamer.h" 27 #include "llvm/MC/SectionKind.h" 28 #include "llvm/Support/ErrorHandling.h" 29 #include "llvm/Target/TargetMachine.h" 30 #include "llvm/Target/TargetOptions.h" 31 using namespace llvm; 32 33 //===----------------------------------------------------------------------===// 34 // Generic Code 35 //===----------------------------------------------------------------------===// 36 37 /// Initialize - this method must be called before any actual lowering is 38 /// done. This specifies the current context for codegen, and gives the 39 /// lowering implementations a chance to set up their default sections. 40 void TargetLoweringObjectFile::Initialize(MCContext &ctx, 41 const TargetMachine &TM) { 42 // `Initialize` can be called more than once. 43 delete Mang; 44 Mang = new Mangler(); 45 initMCObjectFileInfo(ctx, TM.isPositionIndependent(), 46 TM.getCodeModel() == CodeModel::Large); 47 48 // Reset various EH DWARF encodings. 49 PersonalityEncoding = LSDAEncoding = TTypeEncoding = dwarf::DW_EH_PE_absptr; 50 CallSiteEncoding = dwarf::DW_EH_PE_uleb128; 51 52 this->TM = &TM; 53 } 54 55 TargetLoweringObjectFile::~TargetLoweringObjectFile() { 56 delete Mang; 57 } 58 59 unsigned TargetLoweringObjectFile::getCallSiteEncoding() const { 60 // If target does not have LEB128 directives, we would need the 61 // call site encoding to be udata4 so that the alternative path 62 // for not having LEB128 directives could work. 63 if (!getContext().getAsmInfo()->hasLEB128Directives()) 64 return dwarf::DW_EH_PE_udata4; 65 return CallSiteEncoding; 66 } 67 68 static bool isNullOrUndef(const Constant *C) { 69 // Check that the constant isn't all zeros or undefs. 70 if (C->isNullValue() || isa<UndefValue>(C)) 71 return true; 72 if (!isa<ConstantAggregate>(C)) 73 return false; 74 for (const auto *Operand : C->operand_values()) { 75 if (!isNullOrUndef(cast<Constant>(Operand))) 76 return false; 77 } 78 return true; 79 } 80 81 static bool isSuitableForBSS(const GlobalVariable *GV) { 82 const Constant *C = GV->getInitializer(); 83 84 // Must have zero initializer. 85 if (!isNullOrUndef(C)) 86 return false; 87 88 // Leave constant zeros in readonly constant sections, so they can be shared. 89 if (GV->isConstant()) 90 return false; 91 92 // If the global has an explicit section specified, don't put it in BSS. 93 if (GV->hasSection()) 94 return false; 95 96 // Otherwise, put it in BSS! 97 return true; 98 } 99 100 /// IsNullTerminatedString - Return true if the specified constant (which is 101 /// known to have a type that is an array of 1/2/4 byte elements) ends with a 102 /// nul value and contains no other nuls in it. Note that this is more general 103 /// than ConstantDataSequential::isString because we allow 2 & 4 byte strings. 104 static bool IsNullTerminatedString(const Constant *C) { 105 // First check: is we have constant array terminated with zero 106 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(C)) { 107 unsigned NumElts = CDS->getNumElements(); 108 assert(NumElts != 0 && "Can't have an empty CDS"); 109 110 if (CDS->getElementAsInteger(NumElts-1) != 0) 111 return false; // Not null terminated. 112 113 // Verify that the null doesn't occur anywhere else in the string. 114 for (unsigned i = 0; i != NumElts-1; ++i) 115 if (CDS->getElementAsInteger(i) == 0) 116 return false; 117 return true; 118 } 119 120 // Another possibility: [1 x i8] zeroinitializer 121 if (isa<ConstantAggregateZero>(C)) 122 return cast<ArrayType>(C->getType())->getNumElements() == 1; 123 124 return false; 125 } 126 127 MCSymbol *TargetLoweringObjectFile::getSymbolWithGlobalValueBase( 128 const GlobalValue *GV, StringRef Suffix, const TargetMachine &TM) const { 129 assert(!Suffix.empty()); 130 131 SmallString<60> NameStr; 132 NameStr += GV->getDataLayout().getPrivateGlobalPrefix(); 133 TM.getNameWithPrefix(NameStr, GV, *Mang); 134 NameStr.append(Suffix.begin(), Suffix.end()); 135 return getContext().getOrCreateSymbol(NameStr); 136 } 137 138 MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol( 139 const GlobalValue *GV, const TargetMachine &TM, 140 MachineModuleInfo *MMI) const { 141 return TM.getSymbol(GV); 142 } 143 144 void TargetLoweringObjectFile::emitPersonalityValue( 145 MCStreamer &Streamer, const DataLayout &, const MCSymbol *Sym, 146 const MachineModuleInfo *MMI) const {} 147 148 void TargetLoweringObjectFile::emitCGProfileMetadata(MCStreamer &Streamer, 149 Module &M) const { 150 MCContext &C = getContext(); 151 SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags; 152 M.getModuleFlagsMetadata(ModuleFlags); 153 154 MDNode *CFGProfile = nullptr; 155 156 for (const auto &MFE : ModuleFlags) { 157 StringRef Key = MFE.Key->getString(); 158 if (Key == "CG Profile") { 159 CFGProfile = cast<MDNode>(MFE.Val); 160 break; 161 } 162 } 163 164 if (!CFGProfile) 165 return; 166 167 auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * { 168 if (!MDO) 169 return nullptr; 170 auto *V = cast<ValueAsMetadata>(MDO); 171 const Function *F = cast<Function>(V->getValue()->stripPointerCasts()); 172 if (F->hasDLLImportStorageClass()) 173 return nullptr; 174 return TM->getSymbol(F); 175 }; 176 177 for (const auto &Edge : CFGProfile->operands()) { 178 MDNode *E = cast<MDNode>(Edge); 179 const MCSymbol *From = GetSym(E->getOperand(0)); 180 const MCSymbol *To = GetSym(E->getOperand(1)); 181 // Skip null functions. This can happen if functions are dead stripped after 182 // the CGProfile pass has been run. 183 if (!From || !To) 184 continue; 185 uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2)) 186 ->getValue() 187 ->getUniqueInteger() 188 .getZExtValue(); 189 Streamer.emitCGProfileEntry( 190 MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C), 191 MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count); 192 } 193 } 194 195 /// getKindForGlobal - This is a top-level target-independent classifier for 196 /// a global object. Given a global variable and information from the TM, this 197 /// function classifies the global in a target independent manner. This function 198 /// may be overridden by the target implementation. 199 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO, 200 const TargetMachine &TM){ 201 assert(!GO->isDeclarationForLinker() && 202 "Can only be used for global definitions"); 203 204 // Functions are classified as text sections. 205 if (isa<Function>(GO)) 206 return SectionKind::getText(); 207 208 // Basic blocks are classified as text sections. 209 if (isa<BasicBlock>(GO)) 210 return SectionKind::getText(); 211 212 // Global variables require more detailed analysis. 213 const auto *GVar = cast<GlobalVariable>(GO); 214 215 // Handle thread-local data first. 216 if (GVar->isThreadLocal()) { 217 if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) { 218 // Zero-initialized TLS variables with local linkage always get classified 219 // as ThreadBSSLocal. 220 if (GVar->hasLocalLinkage()) { 221 return SectionKind::getThreadBSSLocal(); 222 } 223 return SectionKind::getThreadBSS(); 224 } 225 return SectionKind::getThreadData(); 226 } 227 228 // Variables with common linkage always get classified as common. 229 if (GVar->hasCommonLinkage()) 230 return SectionKind::getCommon(); 231 232 // Most non-mergeable zero data can be put in the BSS section unless otherwise 233 // specified. 234 if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS) { 235 if (GVar->hasLocalLinkage()) 236 return SectionKind::getBSSLocal(); 237 else if (GVar->hasExternalLinkage()) 238 return SectionKind::getBSSExtern(); 239 return SectionKind::getBSS(); 240 } 241 242 // Global variables with '!exclude' should get the exclude section kind if 243 // they have an explicit section and no other metadata. 244 if (GVar->hasSection()) 245 if (MDNode *MD = GVar->getMetadata(LLVMContext::MD_exclude)) 246 if (!MD->getNumOperands()) 247 return SectionKind::getExclude(); 248 249 // If the global is marked constant, we can put it into a mergable section, 250 // a mergable string section, or general .data if it contains relocations. 251 if (GVar->isConstant()) { 252 // If the initializer for the global contains something that requires a 253 // relocation, then we may have to drop this into a writable data section 254 // even though it is marked const. 255 const Constant *C = GVar->getInitializer(); 256 if (!C->needsRelocation()) { 257 // If the global is required to have a unique address, it can't be put 258 // into a mergable section: just drop it into the general read-only 259 // section instead. 260 if (!GVar->hasGlobalUnnamedAddr()) 261 return SectionKind::getReadOnly(); 262 263 // If initializer is a null-terminated string, put it in a "cstring" 264 // section of the right width. 265 if (ArrayType *ATy = dyn_cast<ArrayType>(C->getType())) { 266 if (IntegerType *ITy = 267 dyn_cast<IntegerType>(ATy->getElementType())) { 268 if ((ITy->getBitWidth() == 8 || ITy->getBitWidth() == 16 || 269 ITy->getBitWidth() == 32) && 270 IsNullTerminatedString(C)) { 271 if (ITy->getBitWidth() == 8) 272 return SectionKind::getMergeable1ByteCString(); 273 if (ITy->getBitWidth() == 16) 274 return SectionKind::getMergeable2ByteCString(); 275 276 assert(ITy->getBitWidth() == 32 && "Unknown width"); 277 return SectionKind::getMergeable4ByteCString(); 278 } 279 } 280 } 281 282 // Otherwise, just drop it into a mergable constant section. If we have 283 // a section for this size, use it, otherwise use the arbitrary sized 284 // mergable section. 285 switch ( 286 GVar->getDataLayout().getTypeAllocSize(C->getType())) { 287 case 4: return SectionKind::getMergeableConst4(); 288 case 8: return SectionKind::getMergeableConst8(); 289 case 16: return SectionKind::getMergeableConst16(); 290 case 32: return SectionKind::getMergeableConst32(); 291 default: 292 return SectionKind::getReadOnly(); 293 } 294 295 } else { 296 // In static, ROPI and RWPI relocation models, the linker will resolve 297 // all addresses, so the relocation entries will actually be constants by 298 // the time the app starts up. However, we can't put this into a 299 // mergable section, because the linker doesn't take relocations into 300 // consideration when it tries to merge entries in the section. 301 Reloc::Model ReloModel = TM.getRelocationModel(); 302 if (ReloModel == Reloc::Static || ReloModel == Reloc::ROPI || 303 ReloModel == Reloc::RWPI || ReloModel == Reloc::ROPI_RWPI || 304 !C->needsDynamicRelocation()) 305 return SectionKind::getReadOnly(); 306 307 // Otherwise, the dynamic linker needs to fix it up, put it in the 308 // writable data.rel section. 309 return SectionKind::getReadOnlyWithRel(); 310 } 311 } 312 313 // Okay, this isn't a constant. 314 return SectionKind::getData(); 315 } 316 317 /// This method computes the appropriate section to emit the specified global 318 /// variable or function definition. This should not be passed external (or 319 /// available externally) globals. 320 MCSection *TargetLoweringObjectFile::SectionForGlobal( 321 const GlobalObject *GO, SectionKind Kind, const TargetMachine &TM) const { 322 // Select section name. 323 if (GO->hasSection()) 324 return getExplicitSectionGlobal(GO, Kind, TM); 325 326 if (auto *GVar = dyn_cast<GlobalVariable>(GO)) { 327 auto Attrs = GVar->getAttributes(); 328 if ((Attrs.hasAttribute("bss-section") && Kind.isBSS()) || 329 (Attrs.hasAttribute("data-section") && Kind.isData()) || 330 (Attrs.hasAttribute("relro-section") && Kind.isReadOnlyWithRel()) || 331 (Attrs.hasAttribute("rodata-section") && Kind.isReadOnly())) { 332 return getExplicitSectionGlobal(GO, Kind, TM); 333 } 334 } 335 336 // Use default section depending on the 'type' of global 337 return SelectSectionForGlobal(GO, Kind, TM); 338 } 339 340 /// This method computes the appropriate section to emit the specified global 341 /// variable or function definition. This should not be passed external (or 342 /// available externally) globals. 343 MCSection * 344 TargetLoweringObjectFile::SectionForGlobal(const GlobalObject *GO, 345 const TargetMachine &TM) const { 346 return SectionForGlobal(GO, getKindForGlobal(GO, TM), TM); 347 } 348 349 MCSection *TargetLoweringObjectFile::getSectionForJumpTable( 350 const Function &F, const TargetMachine &TM) const { 351 return getSectionForJumpTable(F, TM, /*JTE=*/nullptr); 352 } 353 354 MCSection *TargetLoweringObjectFile::getSectionForJumpTable( 355 const Function &F, const TargetMachine &TM, 356 const MachineJumpTableEntry *JTE) const { 357 Align Alignment(1); 358 return getSectionForConstant(F.getDataLayout(), 359 SectionKind::getReadOnly(), /*C=*/nullptr, 360 Alignment); 361 } 362 363 bool TargetLoweringObjectFile::shouldPutJumpTableInFunctionSection( 364 bool UsesLabelDifference, const Function &F) const { 365 // In PIC mode, we need to emit the jump table to the same section as the 366 // function body itself, otherwise the label differences won't make sense. 367 // FIXME: Need a better predicate for this: what about custom entries? 368 if (UsesLabelDifference) 369 return true; 370 371 // We should also do if the section name is NULL or function is declared 372 // in discardable section 373 // FIXME: this isn't the right predicate, should be based on the MCSection 374 // for the function. 375 return F.isWeakForLinker(); 376 } 377 378 /// Given a mergable constant with the specified size and relocation 379 /// information, return a section that it should be placed in. 380 MCSection *TargetLoweringObjectFile::getSectionForConstant( 381 const DataLayout &DL, SectionKind Kind, const Constant *C, 382 Align &Alignment) const { 383 if (Kind.isReadOnly() && ReadOnlySection != nullptr) 384 return ReadOnlySection; 385 386 return DataSection; 387 } 388 389 MCSection *TargetLoweringObjectFile::getSectionForMachineBasicBlock( 390 const Function &F, const MachineBasicBlock &MBB, 391 const TargetMachine &TM) const { 392 return nullptr; 393 } 394 395 MCSection *TargetLoweringObjectFile::getUniqueSectionForFunction( 396 const Function &F, const TargetMachine &TM) const { 397 return nullptr; 398 } 399 400 /// getTTypeGlobalReference - Return an MCExpr to use for a 401 /// reference to the specified global variable from exception 402 /// handling information. 403 const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference( 404 const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM, 405 MachineModuleInfo *MMI, MCStreamer &Streamer) const { 406 const MCSymbolRefExpr *Ref = 407 MCSymbolRefExpr::create(TM.getSymbol(GV), getContext()); 408 409 return getTTypeReference(Ref, Encoding, Streamer); 410 } 411 412 const MCExpr *TargetLoweringObjectFile:: 413 getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, 414 MCStreamer &Streamer) const { 415 switch (Encoding & 0x70) { 416 default: 417 report_fatal_error("We do not support this DWARF encoding yet!"); 418 case dwarf::DW_EH_PE_absptr: 419 // Do nothing special 420 return Sym; 421 case dwarf::DW_EH_PE_pcrel: { 422 // Emit a label to the streamer for the current position. This gives us 423 // .-foo addressing. 424 MCSymbol *PCSym = getContext().createTempSymbol(); 425 Streamer.emitLabel(PCSym); 426 const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext()); 427 return MCBinaryExpr::createSub(Sym, PC, getContext()); 428 } 429 } 430 } 431 432 const MCExpr *TargetLoweringObjectFile::getDebugThreadLocalSymbol(const MCSymbol *Sym) const { 433 // FIXME: It's not clear what, if any, default this should have - perhaps a 434 // null return could mean 'no location' & we should just do that here. 435 return MCSymbolRefExpr::create(Sym, getContext()); 436 } 437 438 void TargetLoweringObjectFile::getNameWithPrefix( 439 SmallVectorImpl<char> &OutName, const GlobalValue *GV, 440 const TargetMachine &TM) const { 441 Mang->getNameWithPrefix(OutName, GV, /*CannotUsePrivateLabel=*/false); 442 } 443