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