1//===- AsmPrinter.cpp - Common AsmPrinter code ----------------------------===// 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 the AsmPrinter class. 10// 11//===----------------------------------------------------------------------===// 12 13#include "llvm/CodeGen/AsmPrinter.h" 14#include "CodeViewDebug.h" 15#include "DwarfDebug.h" 16#include "DwarfException.h" 17#include "PseudoProbePrinter.h" 18#include "WasmException.h" 19#include "WinCFGuard.h" 20#include "WinException.h" 21#include "llvm/ADT/APFloat.h" 22#include "llvm/ADT/APInt.h" 23#include "llvm/ADT/DenseMap.h" 24#include "llvm/ADT/STLExtras.h" 25#include "llvm/ADT/SmallPtrSet.h" 26#include "llvm/ADT/SmallString.h" 27#include "llvm/ADT/SmallVector.h" 28#include "llvm/ADT/Statistic.h" 29#include "llvm/ADT/StringRef.h" 30#include "llvm/ADT/Triple.h" 31#include "llvm/ADT/Twine.h" 32#include "llvm/Analysis/ConstantFolding.h" 33#include "llvm/Analysis/EHPersonalities.h" 34#include "llvm/Analysis/MemoryLocation.h" 35#include "llvm/Analysis/OptimizationRemarkEmitter.h" 36#include "llvm/BinaryFormat/COFF.h" 37#include "llvm/BinaryFormat/Dwarf.h" 38#include "llvm/BinaryFormat/ELF.h" 39#include "llvm/CodeGen/GCMetadata.h" 40#include "llvm/CodeGen/GCMetadataPrinter.h" 41#include "llvm/CodeGen/MachineBasicBlock.h" 42#include "llvm/CodeGen/MachineConstantPool.h" 43#include "llvm/CodeGen/MachineDominators.h" 44#include "llvm/CodeGen/MachineFrameInfo.h" 45#include "llvm/CodeGen/MachineFunction.h" 46#include "llvm/CodeGen/MachineFunctionPass.h" 47#include "llvm/CodeGen/MachineInstr.h" 48#include "llvm/CodeGen/MachineInstrBundle.h" 49#include "llvm/CodeGen/MachineJumpTableInfo.h" 50#include "llvm/CodeGen/MachineLoopInfo.h" 51#include "llvm/CodeGen/MachineMemOperand.h" 52#include "llvm/CodeGen/MachineModuleInfo.h" 53#include "llvm/CodeGen/MachineModuleInfoImpls.h" 54#include "llvm/CodeGen/MachineOperand.h" 55#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h" 56#include "llvm/CodeGen/StackMaps.h" 57#include "llvm/CodeGen/TargetFrameLowering.h" 58#include "llvm/CodeGen/TargetInstrInfo.h" 59#include "llvm/CodeGen/TargetLowering.h" 60#include "llvm/CodeGen/TargetOpcodes.h" 61#include "llvm/CodeGen/TargetRegisterInfo.h" 62#include "llvm/IR/BasicBlock.h" 63#include "llvm/IR/Comdat.h" 64#include "llvm/IR/Constant.h" 65#include "llvm/IR/Constants.h" 66#include "llvm/IR/DataLayout.h" 67#include "llvm/IR/DebugInfoMetadata.h" 68#include "llvm/IR/DerivedTypes.h" 69#include "llvm/IR/Function.h" 70#include "llvm/IR/GCStrategy.h" 71#include "llvm/IR/GlobalAlias.h" 72#include "llvm/IR/GlobalIFunc.h" 73#include "llvm/IR/GlobalIndirectSymbol.h" 74#include "llvm/IR/GlobalObject.h" 75#include "llvm/IR/GlobalValue.h" 76#include "llvm/IR/GlobalVariable.h" 77#include "llvm/IR/Instruction.h" 78#include "llvm/IR/Mangler.h" 79#include "llvm/IR/Metadata.h" 80#include "llvm/IR/Module.h" 81#include "llvm/IR/Operator.h" 82#include "llvm/IR/PseudoProbe.h" 83#include "llvm/IR/Type.h" 84#include "llvm/IR/Value.h" 85#include "llvm/MC/MCAsmInfo.h" 86#include "llvm/MC/MCContext.h" 87#include "llvm/MC/MCDirectives.h" 88#include "llvm/MC/MCDwarf.h" 89#include "llvm/MC/MCExpr.h" 90#include "llvm/MC/MCInst.h" 91#include "llvm/MC/MCSection.h" 92#include "llvm/MC/MCSectionCOFF.h" 93#include "llvm/MC/MCSectionELF.h" 94#include "llvm/MC/MCSectionMachO.h" 95#include "llvm/MC/MCSectionXCOFF.h" 96#include "llvm/MC/MCStreamer.h" 97#include "llvm/MC/MCSubtargetInfo.h" 98#include "llvm/MC/MCSymbol.h" 99#include "llvm/MC/MCSymbolELF.h" 100#include "llvm/MC/MCSymbolXCOFF.h" 101#include "llvm/MC/MCTargetOptions.h" 102#include "llvm/MC/MCValue.h" 103#include "llvm/MC/SectionKind.h" 104#include "llvm/Pass.h" 105#include "llvm/Remarks/Remark.h" 106#include "llvm/Remarks/RemarkFormat.h" 107#include "llvm/Remarks/RemarkStreamer.h" 108#include "llvm/Remarks/RemarkStringTable.h" 109#include "llvm/Support/Casting.h" 110#include "llvm/Support/CommandLine.h" 111#include "llvm/Support/Compiler.h" 112#include "llvm/Support/ErrorHandling.h" 113#include "llvm/Support/FileSystem.h" 114#include "llvm/Support/Format.h" 115#include "llvm/Support/MathExtras.h" 116#include "llvm/Support/Path.h" 117#include "llvm/Support/TargetRegistry.h" 118#include "llvm/Support/Timer.h" 119#include "llvm/Support/raw_ostream.h" 120#include "llvm/Target/TargetLoweringObjectFile.h" 121#include "llvm/Target/TargetMachine.h" 122#include "llvm/Target/TargetOptions.h" 123#include <algorithm> 124#include <cassert> 125#include <cinttypes> 126#include <cstdint> 127#include <iterator> 128#include <limits> 129#include <memory> 130#include <string> 131#include <utility> 132#include <vector> 133 134using namespace llvm; 135 136#define DEBUG_TYPE "asm-printer" 137 138// FIXME: this option currently only applies to DWARF, and not CodeView, tables 139static cl::opt<bool> 140 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden, 141 cl::desc("Disable debug info printing")); 142 143const char DWARFGroupName[] = "dwarf"; 144const char DWARFGroupDescription[] = "DWARF Emission"; 145const char DbgTimerName[] = "emit"; 146const char DbgTimerDescription[] = "Debug Info Emission"; 147const char EHTimerName[] = "write_exception"; 148const char EHTimerDescription[] = "DWARF Exception Writer"; 149const char CFGuardName[] = "Control Flow Guard"; 150const char CFGuardDescription[] = "Control Flow Guard"; 151const char CodeViewLineTablesGroupName[] = "linetables"; 152const char CodeViewLineTablesGroupDescription[] = "CodeView Line Tables"; 153const char PPTimerName[] = "emit"; 154const char PPTimerDescription[] = "Pseudo Probe Emission"; 155const char PPGroupName[] = "pseudo probe"; 156const char PPGroupDescription[] = "Pseudo Probe Emission"; 157 158STATISTIC(EmittedInsts, "Number of machine instrs printed"); 159 160char AsmPrinter::ID = 0; 161 162using gcp_map_type = DenseMap<GCStrategy *, std::unique_ptr<GCMetadataPrinter>>; 163 164static gcp_map_type &getGCMap(void *&P) { 165 if (!P) 166 P = new gcp_map_type(); 167 return *(gcp_map_type*)P; 168} 169 170/// getGVAlignment - Return the alignment to use for the specified global 171/// value. This rounds up to the preferred alignment if possible and legal. 172Align AsmPrinter::getGVAlignment(const GlobalObject *GV, const DataLayout &DL, 173 Align InAlign) { 174 Align Alignment; 175 if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) 176 Alignment = DL.getPreferredAlign(GVar); 177 178 // If InAlign is specified, round it to it. 179 if (InAlign > Alignment) 180 Alignment = InAlign; 181 182 // If the GV has a specified alignment, take it into account. 183 const MaybeAlign GVAlign(GV->getAlignment()); 184 if (!GVAlign) 185 return Alignment; 186 187 assert(GVAlign && "GVAlign must be set"); 188 189 // If the GVAlign is larger than NumBits, or if we are required to obey 190 // NumBits because the GV has an assigned section, obey it. 191 if (*GVAlign > Alignment || GV->hasSection()) 192 Alignment = *GVAlign; 193 return Alignment; 194} 195 196AsmPrinter::AsmPrinter(TargetMachine &tm, std::unique_ptr<MCStreamer> Streamer) 197 : MachineFunctionPass(ID), TM(tm), MAI(tm.getMCAsmInfo()), 198 OutContext(Streamer->getContext()), OutStreamer(std::move(Streamer)) { 199 VerboseAsm = OutStreamer->isVerboseAsm(); 200} 201 202AsmPrinter::~AsmPrinter() { 203 assert(!DD && Handlers.size() == NumUserHandlers && 204 "Debug/EH info didn't get finalized"); 205 206 if (GCMetadataPrinters) { 207 gcp_map_type &GCMap = getGCMap(GCMetadataPrinters); 208 209 delete &GCMap; 210 GCMetadataPrinters = nullptr; 211 } 212} 213 214bool AsmPrinter::isPositionIndependent() const { 215 return TM.isPositionIndependent(); 216} 217 218/// getFunctionNumber - Return a unique ID for the current function. 219unsigned AsmPrinter::getFunctionNumber() const { 220 return MF->getFunctionNumber(); 221} 222 223const TargetLoweringObjectFile &AsmPrinter::getObjFileLowering() const { 224 return *TM.getObjFileLowering(); 225} 226 227const DataLayout &AsmPrinter::getDataLayout() const { 228 return MMI->getModule()->getDataLayout(); 229} 230 231// Do not use the cached DataLayout because some client use it without a Module 232// (dsymutil, llvm-dwarfdump). 233unsigned AsmPrinter::getPointerSize() const { 234 return TM.getPointerSize(0); // FIXME: Default address space 235} 236 237const MCSubtargetInfo &AsmPrinter::getSubtargetInfo() const { 238 assert(MF && "getSubtargetInfo requires a valid MachineFunction!"); 239 return MF->getSubtarget<MCSubtargetInfo>(); 240} 241 242void AsmPrinter::EmitToStreamer(MCStreamer &S, const MCInst &Inst) { 243 S.emitInstruction(Inst, getSubtargetInfo()); 244} 245 246void AsmPrinter::emitInitialRawDwarfLocDirective(const MachineFunction &MF) { 247 if (DD) { 248 assert(OutStreamer->hasRawTextSupport() && 249 "Expected assembly output mode."); 250 (void)DD->emitInitialLocDirective(MF, /*CUID=*/0); 251 } 252} 253 254/// getCurrentSection() - Return the current section we are emitting to. 255const MCSection *AsmPrinter::getCurrentSection() const { 256 return OutStreamer->getCurrentSectionOnly(); 257} 258 259void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const { 260 AU.setPreservesAll(); 261 MachineFunctionPass::getAnalysisUsage(AU); 262 AU.addRequired<MachineOptimizationRemarkEmitterPass>(); 263 AU.addRequired<GCModuleInfo>(); 264} 265 266bool AsmPrinter::doInitialization(Module &M) { 267 auto *MMIWP = getAnalysisIfAvailable<MachineModuleInfoWrapperPass>(); 268 MMI = MMIWP ? &MMIWP->getMMI() : nullptr; 269 270 // Initialize TargetLoweringObjectFile. 271 const_cast<TargetLoweringObjectFile&>(getObjFileLowering()) 272 .Initialize(OutContext, TM); 273 274 const_cast<TargetLoweringObjectFile &>(getObjFileLowering()) 275 .getModuleMetadata(M); 276 277 OutStreamer->InitSections(false); 278 279 if (DisableDebugInfoPrinting) 280 MMI->setDebugInfoAvailability(false); 281 282 // Emit the version-min deployment target directive if needed. 283 // 284 // FIXME: If we end up with a collection of these sorts of Darwin-specific 285 // or ELF-specific things, it may make sense to have a platform helper class 286 // that will work with the target helper class. For now keep it here, as the 287 // alternative is duplicated code in each of the target asm printers that 288 // use the directive, where it would need the same conditionalization 289 // anyway. 290 const Triple &Target = TM.getTargetTriple(); 291 OutStreamer->emitVersionForTarget(Target, M.getSDKVersion()); 292 293 // Allow the target to emit any magic that it wants at the start of the file. 294 emitStartOfAsmFile(M); 295 296 // Very minimal debug info. It is ignored if we emit actual debug info. If we 297 // don't, this at least helps the user find where a global came from. 298 if (MAI->hasSingleParameterDotFile()) { 299 // .file "foo.c" 300 if (MAI->hasBasenameOnlyForFileDirective()) 301 OutStreamer->emitFileDirective( 302 llvm::sys::path::filename(M.getSourceFileName())); 303 else 304 OutStreamer->emitFileDirective(M.getSourceFileName()); 305 } 306 307 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 308 assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 309 for (auto &I : *MI) 310 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) 311 MP->beginAssembly(M, *MI, *this); 312 313 // Emit module-level inline asm if it exists. 314 if (!M.getModuleInlineAsm().empty()) { 315 // We're at the module level. Construct MCSubtarget from the default CPU 316 // and target triple. 317 std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo( 318 TM.getTargetTriple().str(), TM.getTargetCPU(), 319 TM.getTargetFeatureString())); 320 assert(STI && "Unable to create subtarget info"); 321 OutStreamer->AddComment("Start of file scope inline assembly"); 322 OutStreamer->AddBlankLine(); 323 emitInlineAsm(M.getModuleInlineAsm() + "\n", 324 OutContext.getSubtargetCopy(*STI), TM.Options.MCOptions); 325 OutStreamer->AddComment("End of file scope inline assembly"); 326 OutStreamer->AddBlankLine(); 327 } 328 329 if (MAI->doesSupportDebugInformation()) { 330 bool EmitCodeView = M.getCodeViewFlag(); 331 if (EmitCodeView && TM.getTargetTriple().isOSWindows()) { 332 Handlers.emplace_back(std::make_unique<CodeViewDebug>(this), 333 DbgTimerName, DbgTimerDescription, 334 CodeViewLineTablesGroupName, 335 CodeViewLineTablesGroupDescription); 336 } 337 if (!EmitCodeView || M.getDwarfVersion()) { 338 if (!DisableDebugInfoPrinting) { 339 DD = new DwarfDebug(this); 340 Handlers.emplace_back(std::unique_ptr<DwarfDebug>(DD), DbgTimerName, 341 DbgTimerDescription, DWARFGroupName, 342 DWARFGroupDescription); 343 } 344 } 345 } 346 347 if (M.getNamedMetadata(PseudoProbeDescMetadataName)) { 348 PP = new PseudoProbeHandler(this, &M); 349 Handlers.emplace_back(std::unique_ptr<PseudoProbeHandler>(PP), PPTimerName, 350 PPTimerDescription, PPGroupName, PPGroupDescription); 351 } 352 353 switch (MAI->getExceptionHandlingType()) { 354 case ExceptionHandling::None: 355 // We may want to emit CFI for debug. 356 LLVM_FALLTHROUGH; 357 case ExceptionHandling::SjLj: 358 case ExceptionHandling::DwarfCFI: 359 case ExceptionHandling::ARM: 360 for (auto &F : M.getFunctionList()) { 361 if (getFunctionCFISectionType(F) != CFISection::None) 362 ModuleCFISection = getFunctionCFISectionType(F); 363 // If any function needsUnwindTableEntry(), it needs .eh_frame and hence 364 // the module needs .eh_frame. If we have found that case, we are done. 365 if (ModuleCFISection == CFISection::EH) 366 break; 367 } 368 assert(MAI->getExceptionHandlingType() == ExceptionHandling::DwarfCFI || 369 ModuleCFISection != CFISection::EH); 370 break; 371 default: 372 break; 373 } 374 375 EHStreamer *ES = nullptr; 376 switch (MAI->getExceptionHandlingType()) { 377 case ExceptionHandling::None: 378 if (!needsCFIForDebug()) 379 break; 380 LLVM_FALLTHROUGH; 381 case ExceptionHandling::SjLj: 382 case ExceptionHandling::DwarfCFI: 383 ES = new DwarfCFIException(this); 384 break; 385 case ExceptionHandling::ARM: 386 ES = new ARMException(this); 387 break; 388 case ExceptionHandling::WinEH: 389 switch (MAI->getWinEHEncodingType()) { 390 default: llvm_unreachable("unsupported unwinding information encoding"); 391 case WinEH::EncodingType::Invalid: 392 break; 393 case WinEH::EncodingType::X86: 394 case WinEH::EncodingType::Itanium: 395 ES = new WinException(this); 396 break; 397 } 398 break; 399 case ExceptionHandling::Wasm: 400 ES = new WasmException(this); 401 break; 402 case ExceptionHandling::AIX: 403 ES = new AIXException(this); 404 break; 405 } 406 if (ES) 407 Handlers.emplace_back(std::unique_ptr<EHStreamer>(ES), EHTimerName, 408 EHTimerDescription, DWARFGroupName, 409 DWARFGroupDescription); 410 411 // Emit tables for any value of cfguard flag (i.e. cfguard=1 or cfguard=2). 412 if (mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("cfguard"))) 413 Handlers.emplace_back(std::make_unique<WinCFGuard>(this), CFGuardName, 414 CFGuardDescription, DWARFGroupName, 415 DWARFGroupDescription); 416 417 for (const HandlerInfo &HI : Handlers) { 418 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 419 HI.TimerGroupDescription, TimePassesIsEnabled); 420 HI.Handler->beginModule(&M); 421 } 422 423 return false; 424} 425 426static bool canBeHidden(const GlobalValue *GV, const MCAsmInfo &MAI) { 427 if (!MAI.hasWeakDefCanBeHiddenDirective()) 428 return false; 429 430 return GV->canBeOmittedFromSymbolTable(); 431} 432 433void AsmPrinter::emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const { 434 GlobalValue::LinkageTypes Linkage = GV->getLinkage(); 435 switch (Linkage) { 436 case GlobalValue::CommonLinkage: 437 case GlobalValue::LinkOnceAnyLinkage: 438 case GlobalValue::LinkOnceODRLinkage: 439 case GlobalValue::WeakAnyLinkage: 440 case GlobalValue::WeakODRLinkage: 441 if (MAI->hasWeakDefDirective()) { 442 // .globl _foo 443 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global); 444 445 if (!canBeHidden(GV, *MAI)) 446 // .weak_definition _foo 447 OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefinition); 448 else 449 OutStreamer->emitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate); 450 } else if (MAI->avoidWeakIfComdat() && GV->hasComdat()) { 451 // .globl _foo 452 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global); 453 //NOTE: linkonce is handled by the section the symbol was assigned to. 454 } else { 455 // .weak _foo 456 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Weak); 457 } 458 return; 459 case GlobalValue::ExternalLinkage: 460 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Global); 461 return; 462 case GlobalValue::PrivateLinkage: 463 case GlobalValue::InternalLinkage: 464 return; 465 case GlobalValue::ExternalWeakLinkage: 466 case GlobalValue::AvailableExternallyLinkage: 467 case GlobalValue::AppendingLinkage: 468 llvm_unreachable("Should never emit this"); 469 } 470 llvm_unreachable("Unknown linkage type!"); 471} 472 473void AsmPrinter::getNameWithPrefix(SmallVectorImpl<char> &Name, 474 const GlobalValue *GV) const { 475 TM.getNameWithPrefix(Name, GV, getObjFileLowering().getMangler()); 476} 477 478MCSymbol *AsmPrinter::getSymbol(const GlobalValue *GV) const { 479 return TM.getSymbol(GV); 480} 481 482MCSymbol *AsmPrinter::getSymbolPreferLocal(const GlobalValue &GV) const { 483 // On ELF, use .Lfoo$local if GV is a non-interposable GlobalObject with an 484 // exact definion (intersection of GlobalValue::hasExactDefinition() and 485 // !isInterposable()). These linkages include: external, appending, internal, 486 // private. It may be profitable to use a local alias for external. The 487 // assembler would otherwise be conservative and assume a global default 488 // visibility symbol can be interposable, even if the code generator already 489 // assumed it. 490 if (TM.getTargetTriple().isOSBinFormatELF() && GV.canBenefitFromLocalAlias()) { 491 const Module &M = *GV.getParent(); 492 if (TM.getRelocationModel() != Reloc::Static && 493 M.getPIELevel() == PIELevel::Default && GV.isDSOLocal()) 494 return getSymbolWithGlobalValueBase(&GV, "$local"); 495 } 496 return TM.getSymbol(&GV); 497} 498 499/// EmitGlobalVariable - Emit the specified global variable to the .s file. 500void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { 501 bool IsEmuTLSVar = TM.useEmulatedTLS() && GV->isThreadLocal(); 502 assert(!(IsEmuTLSVar && GV->hasCommonLinkage()) && 503 "No emulated TLS variables in the common section"); 504 505 // Never emit TLS variable xyz in emulated TLS model. 506 // The initialization value is in __emutls_t.xyz instead of xyz. 507 if (IsEmuTLSVar) 508 return; 509 510 if (GV->hasInitializer()) { 511 // Check to see if this is a special global used by LLVM, if so, emit it. 512 if (emitSpecialLLVMGlobal(GV)) 513 return; 514 515 // Skip the emission of global equivalents. The symbol can be emitted later 516 // on by emitGlobalGOTEquivs in case it turns out to be needed. 517 if (GlobalGOTEquivs.count(getSymbol(GV))) 518 return; 519 520 if (isVerbose()) { 521 // When printing the control variable __emutls_v.*, 522 // we don't need to print the original TLS variable name. 523 GV->printAsOperand(OutStreamer->GetCommentOS(), 524 /*PrintType=*/false, GV->getParent()); 525 OutStreamer->GetCommentOS() << '\n'; 526 } 527 } 528 529 MCSymbol *GVSym = getSymbol(GV); 530 MCSymbol *EmittedSym = GVSym; 531 532 // getOrCreateEmuTLSControlSym only creates the symbol with name and default 533 // attributes. 534 // GV's or GVSym's attributes will be used for the EmittedSym. 535 emitVisibility(EmittedSym, GV->getVisibility(), !GV->isDeclaration()); 536 537 if (!GV->hasInitializer()) // External globals require no extra code. 538 return; 539 540 GVSym->redefineIfPossible(); 541 if (GVSym->isDefined() || GVSym->isVariable()) 542 OutContext.reportError(SMLoc(), "symbol '" + Twine(GVSym->getName()) + 543 "' is already defined"); 544 545 if (MAI->hasDotTypeDotSizeDirective()) 546 OutStreamer->emitSymbolAttribute(EmittedSym, MCSA_ELF_TypeObject); 547 548 SectionKind GVKind = TargetLoweringObjectFile::getKindForGlobal(GV, TM); 549 550 const DataLayout &DL = GV->getParent()->getDataLayout(); 551 uint64_t Size = DL.getTypeAllocSize(GV->getValueType()); 552 553 // If the alignment is specified, we *must* obey it. Overaligning a global 554 // with a specified alignment is a prompt way to break globals emitted to 555 // sections and expected to be contiguous (e.g. ObjC metadata). 556 const Align Alignment = getGVAlignment(GV, DL); 557 558 for (const HandlerInfo &HI : Handlers) { 559 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, 560 HI.TimerGroupName, HI.TimerGroupDescription, 561 TimePassesIsEnabled); 562 HI.Handler->setSymbolSize(GVSym, Size); 563 } 564 565 // Handle common symbols 566 if (GVKind.isCommon()) { 567 if (Size == 0) Size = 1; // .comm Foo, 0 is undefined, avoid it. 568 // .comm _foo, 42, 4 569 const bool SupportsAlignment = 570 getObjFileLowering().getCommDirectiveSupportsAlignment(); 571 OutStreamer->emitCommonSymbol(GVSym, Size, 572 SupportsAlignment ? Alignment.value() : 0); 573 return; 574 } 575 576 // Determine to which section this global should be emitted. 577 MCSection *TheSection = getObjFileLowering().SectionForGlobal(GV, GVKind, TM); 578 579 // If we have a bss global going to a section that supports the 580 // zerofill directive, do so here. 581 if (GVKind.isBSS() && MAI->hasMachoZeroFillDirective() && 582 TheSection->isVirtualSection()) { 583 if (Size == 0) 584 Size = 1; // zerofill of 0 bytes is undefined. 585 emitLinkage(GV, GVSym); 586 // .zerofill __DATA, __bss, _foo, 400, 5 587 OutStreamer->emitZerofill(TheSection, GVSym, Size, Alignment.value()); 588 return; 589 } 590 591 // If this is a BSS local symbol and we are emitting in the BSS 592 // section use .lcomm/.comm directive. 593 if (GVKind.isBSSLocal() && 594 getObjFileLowering().getBSSSection() == TheSection) { 595 if (Size == 0) 596 Size = 1; // .comm Foo, 0 is undefined, avoid it. 597 598 // Use .lcomm only if it supports user-specified alignment. 599 // Otherwise, while it would still be correct to use .lcomm in some 600 // cases (e.g. when Align == 1), the external assembler might enfore 601 // some -unknown- default alignment behavior, which could cause 602 // spurious differences between external and integrated assembler. 603 // Prefer to simply fall back to .local / .comm in this case. 604 if (MAI->getLCOMMDirectiveAlignmentType() != LCOMM::NoAlignment) { 605 // .lcomm _foo, 42 606 OutStreamer->emitLocalCommonSymbol(GVSym, Size, Alignment.value()); 607 return; 608 } 609 610 // .local _foo 611 OutStreamer->emitSymbolAttribute(GVSym, MCSA_Local); 612 // .comm _foo, 42, 4 613 const bool SupportsAlignment = 614 getObjFileLowering().getCommDirectiveSupportsAlignment(); 615 OutStreamer->emitCommonSymbol(GVSym, Size, 616 SupportsAlignment ? Alignment.value() : 0); 617 return; 618 } 619 620 // Handle thread local data for mach-o which requires us to output an 621 // additional structure of data and mangle the original symbol so that we 622 // can reference it later. 623 // 624 // TODO: This should become an "emit thread local global" method on TLOF. 625 // All of this macho specific stuff should be sunk down into TLOFMachO and 626 // stuff like "TLSExtraDataSection" should no longer be part of the parent 627 // TLOF class. This will also make it more obvious that stuff like 628 // MCStreamer::EmitTBSSSymbol is macho specific and only called from macho 629 // specific code. 630 if (GVKind.isThreadLocal() && MAI->hasMachoTBSSDirective()) { 631 // Emit the .tbss symbol 632 MCSymbol *MangSym = 633 OutContext.getOrCreateSymbol(GVSym->getName() + Twine("$tlv$init")); 634 635 if (GVKind.isThreadBSS()) { 636 TheSection = getObjFileLowering().getTLSBSSSection(); 637 OutStreamer->emitTBSSSymbol(TheSection, MangSym, Size, Alignment.value()); 638 } else if (GVKind.isThreadData()) { 639 OutStreamer->SwitchSection(TheSection); 640 641 emitAlignment(Alignment, GV); 642 OutStreamer->emitLabel(MangSym); 643 644 emitGlobalConstant(GV->getParent()->getDataLayout(), 645 GV->getInitializer()); 646 } 647 648 OutStreamer->AddBlankLine(); 649 650 // Emit the variable struct for the runtime. 651 MCSection *TLVSect = getObjFileLowering().getTLSExtraDataSection(); 652 653 OutStreamer->SwitchSection(TLVSect); 654 // Emit the linkage here. 655 emitLinkage(GV, GVSym); 656 OutStreamer->emitLabel(GVSym); 657 658 // Three pointers in size: 659 // - __tlv_bootstrap - used to make sure support exists 660 // - spare pointer, used when mapped by the runtime 661 // - pointer to mangled symbol above with initializer 662 unsigned PtrSize = DL.getPointerTypeSize(GV->getType()); 663 OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"), 664 PtrSize); 665 OutStreamer->emitIntValue(0, PtrSize); 666 OutStreamer->emitSymbolValue(MangSym, PtrSize); 667 668 OutStreamer->AddBlankLine(); 669 return; 670 } 671 672 MCSymbol *EmittedInitSym = GVSym; 673 674 OutStreamer->SwitchSection(TheSection); 675 676 emitLinkage(GV, EmittedInitSym); 677 emitAlignment(Alignment, GV); 678 679 OutStreamer->emitLabel(EmittedInitSym); 680 MCSymbol *LocalAlias = getSymbolPreferLocal(*GV); 681 if (LocalAlias != EmittedInitSym) 682 OutStreamer->emitLabel(LocalAlias); 683 684 emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer()); 685 686 if (MAI->hasDotTypeDotSizeDirective()) 687 // .size foo, 42 688 OutStreamer->emitELFSize(EmittedInitSym, 689 MCConstantExpr::create(Size, OutContext)); 690 691 OutStreamer->AddBlankLine(); 692} 693 694/// Emit the directive and value for debug thread local expression 695/// 696/// \p Value - The value to emit. 697/// \p Size - The size of the integer (in bytes) to emit. 698void AsmPrinter::emitDebugValue(const MCExpr *Value, unsigned Size) const { 699 OutStreamer->emitValue(Value, Size); 700} 701 702void AsmPrinter::emitFunctionHeaderComment() {} 703 704/// EmitFunctionHeader - This method emits the header for the current 705/// function. 706void AsmPrinter::emitFunctionHeader() { 707 const Function &F = MF->getFunction(); 708 709 if (isVerbose()) 710 OutStreamer->GetCommentOS() 711 << "-- Begin function " 712 << GlobalValue::dropLLVMManglingEscape(F.getName()) << '\n'; 713 714 // Print out constants referenced by the function 715 emitConstantPool(); 716 717 // Print the 'header' of function. 718 // If basic block sections are desired, explicitly request a unique section 719 // for this function's entry block. 720 if (MF->front().isBeginSection()) 721 MF->setSection(getObjFileLowering().getUniqueSectionForFunction(F, TM)); 722 else 723 MF->setSection(getObjFileLowering().SectionForGlobal(&F, TM)); 724 OutStreamer->SwitchSection(MF->getSection()); 725 726 if (!MAI->hasVisibilityOnlyWithLinkage()) 727 emitVisibility(CurrentFnSym, F.getVisibility()); 728 729 if (MAI->needsFunctionDescriptors()) 730 emitLinkage(&F, CurrentFnDescSym); 731 732 emitLinkage(&F, CurrentFnSym); 733 if (MAI->hasFunctionAlignment()) 734 emitAlignment(MF->getAlignment(), &F); 735 736 if (MAI->hasDotTypeDotSizeDirective()) 737 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction); 738 739 if (F.hasFnAttribute(Attribute::Cold)) 740 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_Cold); 741 742 if (isVerbose()) { 743 F.printAsOperand(OutStreamer->GetCommentOS(), 744 /*PrintType=*/false, F.getParent()); 745 emitFunctionHeaderComment(); 746 OutStreamer->GetCommentOS() << '\n'; 747 } 748 749 // Emit the prefix data. 750 if (F.hasPrefixData()) { 751 if (MAI->hasSubsectionsViaSymbols()) { 752 // Preserving prefix data on platforms which use subsections-via-symbols 753 // is a bit tricky. Here we introduce a symbol for the prefix data 754 // and use the .alt_entry attribute to mark the function's real entry point 755 // as an alternative entry point to the prefix-data symbol. 756 MCSymbol *PrefixSym = OutContext.createLinkerPrivateTempSymbol(); 757 OutStreamer->emitLabel(PrefixSym); 758 759 emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrefixData()); 760 761 // Emit an .alt_entry directive for the actual function symbol. 762 OutStreamer->emitSymbolAttribute(CurrentFnSym, MCSA_AltEntry); 763 } else { 764 emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrefixData()); 765 } 766 } 767 768 // Emit M NOPs for -fpatchable-function-entry=N,M where M>0. We arbitrarily 769 // place prefix data before NOPs. 770 unsigned PatchableFunctionPrefix = 0; 771 unsigned PatchableFunctionEntry = 0; 772 (void)F.getFnAttribute("patchable-function-prefix") 773 .getValueAsString() 774 .getAsInteger(10, PatchableFunctionPrefix); 775 (void)F.getFnAttribute("patchable-function-entry") 776 .getValueAsString() 777 .getAsInteger(10, PatchableFunctionEntry); 778 if (PatchableFunctionPrefix) { 779 CurrentPatchableFunctionEntrySym = 780 OutContext.createLinkerPrivateTempSymbol(); 781 OutStreamer->emitLabel(CurrentPatchableFunctionEntrySym); 782 emitNops(PatchableFunctionPrefix); 783 } else if (PatchableFunctionEntry) { 784 // May be reassigned when emitting the body, to reference the label after 785 // the initial BTI (AArch64) or endbr32/endbr64 (x86). 786 CurrentPatchableFunctionEntrySym = CurrentFnBegin; 787 } 788 789 // Emit the function descriptor. This is a virtual function to allow targets 790 // to emit their specific function descriptor. Right now it is only used by 791 // the AIX target. The PowerPC 64-bit V1 ELF target also uses function 792 // descriptors and should be converted to use this hook as well. 793 if (MAI->needsFunctionDescriptors()) 794 emitFunctionDescriptor(); 795 796 // Emit the CurrentFnSym. This is a virtual function to allow targets to do 797 // their wild and crazy things as required. 798 emitFunctionEntryLabel(); 799 800 // If the function had address-taken blocks that got deleted, then we have 801 // references to the dangling symbols. Emit them at the start of the function 802 // so that we don't get references to undefined symbols. 803 std::vector<MCSymbol*> DeadBlockSyms; 804 MMI->takeDeletedSymbolsForFunction(&F, DeadBlockSyms); 805 for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) { 806 OutStreamer->AddComment("Address taken block that was later removed"); 807 OutStreamer->emitLabel(DeadBlockSyms[i]); 808 } 809 810 if (CurrentFnBegin) { 811 if (MAI->useAssignmentForEHBegin()) { 812 MCSymbol *CurPos = OutContext.createTempSymbol(); 813 OutStreamer->emitLabel(CurPos); 814 OutStreamer->emitAssignment(CurrentFnBegin, 815 MCSymbolRefExpr::create(CurPos, OutContext)); 816 } else { 817 OutStreamer->emitLabel(CurrentFnBegin); 818 } 819 } 820 821 // Emit pre-function debug and/or EH information. 822 for (const HandlerInfo &HI : Handlers) { 823 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 824 HI.TimerGroupDescription, TimePassesIsEnabled); 825 HI.Handler->beginFunction(MF); 826 } 827 828 // Emit the prologue data. 829 if (F.hasPrologueData()) 830 emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrologueData()); 831} 832 833/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the 834/// function. This can be overridden by targets as required to do custom stuff. 835void AsmPrinter::emitFunctionEntryLabel() { 836 CurrentFnSym->redefineIfPossible(); 837 838 // The function label could have already been emitted if two symbols end up 839 // conflicting due to asm renaming. Detect this and emit an error. 840 if (CurrentFnSym->isVariable()) 841 report_fatal_error("'" + Twine(CurrentFnSym->getName()) + 842 "' is a protected alias"); 843 844 OutStreamer->emitLabel(CurrentFnSym); 845 846 if (TM.getTargetTriple().isOSBinFormatELF()) { 847 MCSymbol *Sym = getSymbolPreferLocal(MF->getFunction()); 848 if (Sym != CurrentFnSym) 849 OutStreamer->emitLabel(Sym); 850 } 851} 852 853/// emitComments - Pretty-print comments for instructions. 854static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) { 855 const MachineFunction *MF = MI.getMF(); 856 const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo(); 857 858 // Check for spills and reloads 859 860 // We assume a single instruction only has a spill or reload, not 861 // both. 862 Optional<unsigned> Size; 863 if ((Size = MI.getRestoreSize(TII))) { 864 CommentOS << *Size << "-byte Reload\n"; 865 } else if ((Size = MI.getFoldedRestoreSize(TII))) { 866 if (*Size) { 867 if (*Size == unsigned(MemoryLocation::UnknownSize)) 868 CommentOS << "Unknown-size Folded Reload\n"; 869 else 870 CommentOS << *Size << "-byte Folded Reload\n"; 871 } 872 } else if ((Size = MI.getSpillSize(TII))) { 873 CommentOS << *Size << "-byte Spill\n"; 874 } else if ((Size = MI.getFoldedSpillSize(TII))) { 875 if (*Size) { 876 if (*Size == unsigned(MemoryLocation::UnknownSize)) 877 CommentOS << "Unknown-size Folded Spill\n"; 878 else 879 CommentOS << *Size << "-byte Folded Spill\n"; 880 } 881 } 882 883 // Check for spill-induced copies 884 if (MI.getAsmPrinterFlag(MachineInstr::ReloadReuse)) 885 CommentOS << " Reload Reuse\n"; 886} 887 888/// emitImplicitDef - This method emits the specified machine instruction 889/// that is an implicit def. 890void AsmPrinter::emitImplicitDef(const MachineInstr *MI) const { 891 Register RegNo = MI->getOperand(0).getReg(); 892 893 SmallString<128> Str; 894 raw_svector_ostream OS(Str); 895 OS << "implicit-def: " 896 << printReg(RegNo, MF->getSubtarget().getRegisterInfo()); 897 898 OutStreamer->AddComment(OS.str()); 899 OutStreamer->AddBlankLine(); 900} 901 902static void emitKill(const MachineInstr *MI, AsmPrinter &AP) { 903 std::string Str; 904 raw_string_ostream OS(Str); 905 OS << "kill:"; 906 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 907 const MachineOperand &Op = MI->getOperand(i); 908 assert(Op.isReg() && "KILL instruction must have only register operands"); 909 OS << ' ' << (Op.isDef() ? "def " : "killed ") 910 << printReg(Op.getReg(), AP.MF->getSubtarget().getRegisterInfo()); 911 } 912 AP.OutStreamer->AddComment(OS.str()); 913 AP.OutStreamer->AddBlankLine(); 914} 915 916/// emitDebugValueComment - This method handles the target-independent form 917/// of DBG_VALUE, returning true if it was able to do so. A false return 918/// means the target will need to handle MI in EmitInstruction. 919static bool emitDebugValueComment(const MachineInstr *MI, AsmPrinter &AP) { 920 // This code handles only the 4-operand target-independent form. 921 if (MI->isNonListDebugValue() && MI->getNumOperands() != 4) 922 return false; 923 924 SmallString<128> Str; 925 raw_svector_ostream OS(Str); 926 OS << "DEBUG_VALUE: "; 927 928 const DILocalVariable *V = MI->getDebugVariable(); 929 if (auto *SP = dyn_cast<DISubprogram>(V->getScope())) { 930 StringRef Name = SP->getName(); 931 if (!Name.empty()) 932 OS << Name << ":"; 933 } 934 OS << V->getName(); 935 OS << " <- "; 936 937 const DIExpression *Expr = MI->getDebugExpression(); 938 if (Expr->getNumElements()) { 939 OS << '['; 940 ListSeparator LS; 941 for (auto Op : Expr->expr_ops()) { 942 OS << LS << dwarf::OperationEncodingString(Op.getOp()); 943 for (unsigned I = 0; I < Op.getNumArgs(); ++I) 944 OS << ' ' << Op.getArg(I); 945 } 946 OS << "] "; 947 } 948 949 // Register or immediate value. Register 0 means undef. 950 for (const MachineOperand &Op : MI->debug_operands()) { 951 if (&Op != MI->debug_operands().begin()) 952 OS << ", "; 953 switch (Op.getType()) { 954 case MachineOperand::MO_FPImmediate: { 955 APFloat APF = APFloat(Op.getFPImm()->getValueAPF()); 956 Type *ImmTy = Op.getFPImm()->getType(); 957 if (ImmTy->isBFloatTy() || ImmTy->isHalfTy() || ImmTy->isFloatTy() || 958 ImmTy->isDoubleTy()) { 959 OS << APF.convertToDouble(); 960 } else { 961 // There is no good way to print long double. Convert a copy to 962 // double. Ah well, it's only a comment. 963 bool ignored; 964 APF.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, 965 &ignored); 966 OS << "(long double) " << APF.convertToDouble(); 967 } 968 break; 969 } 970 case MachineOperand::MO_Immediate: { 971 OS << Op.getImm(); 972 break; 973 } 974 case MachineOperand::MO_CImmediate: { 975 Op.getCImm()->getValue().print(OS, false /*isSigned*/); 976 break; 977 } 978 case MachineOperand::MO_TargetIndex: { 979 OS << "!target-index(" << Op.getIndex() << "," << Op.getOffset() << ")"; 980 // NOTE: Want this comment at start of line, don't emit with AddComment. 981 AP.OutStreamer->emitRawComment(OS.str()); 982 break; 983 } 984 case MachineOperand::MO_Register: 985 case MachineOperand::MO_FrameIndex: { 986 Register Reg; 987 Optional<StackOffset> Offset; 988 if (Op.isReg()) { 989 Reg = Op.getReg(); 990 } else { 991 const TargetFrameLowering *TFI = 992 AP.MF->getSubtarget().getFrameLowering(); 993 Offset = TFI->getFrameIndexReference(*AP.MF, Op.getIndex(), Reg); 994 } 995 if (!Reg) { 996 // Suppress offset, it is not meaningful here. 997 OS << "undef"; 998 break; 999 } 1000 // The second operand is only an offset if it's an immediate. 1001 if (MI->isIndirectDebugValue()) 1002 Offset = StackOffset::getFixed(MI->getDebugOffset().getImm()); 1003 if (Offset) 1004 OS << '['; 1005 OS << printReg(Reg, AP.MF->getSubtarget().getRegisterInfo()); 1006 if (Offset) 1007 OS << '+' << Offset->getFixed() << ']'; 1008 break; 1009 } 1010 default: 1011 llvm_unreachable("Unknown operand type"); 1012 } 1013 } 1014 1015 // NOTE: Want this comment at start of line, don't emit with AddComment. 1016 AP.OutStreamer->emitRawComment(OS.str()); 1017 return true; 1018} 1019 1020/// This method handles the target-independent form of DBG_LABEL, returning 1021/// true if it was able to do so. A false return means the target will need 1022/// to handle MI in EmitInstruction. 1023static bool emitDebugLabelComment(const MachineInstr *MI, AsmPrinter &AP) { 1024 if (MI->getNumOperands() != 1) 1025 return false; 1026 1027 SmallString<128> Str; 1028 raw_svector_ostream OS(Str); 1029 OS << "DEBUG_LABEL: "; 1030 1031 const DILabel *V = MI->getDebugLabel(); 1032 if (auto *SP = dyn_cast<DISubprogram>( 1033 V->getScope()->getNonLexicalBlockFileScope())) { 1034 StringRef Name = SP->getName(); 1035 if (!Name.empty()) 1036 OS << Name << ":"; 1037 } 1038 OS << V->getName(); 1039 1040 // NOTE: Want this comment at start of line, don't emit with AddComment. 1041 AP.OutStreamer->emitRawComment(OS.str()); 1042 return true; 1043} 1044 1045AsmPrinter::CFISection 1046AsmPrinter::getFunctionCFISectionType(const Function &F) const { 1047 // Ignore functions that won't get emitted. 1048 if (F.isDeclarationForLinker()) 1049 return CFISection::None; 1050 1051 if (MAI->getExceptionHandlingType() == ExceptionHandling::DwarfCFI && 1052 F.needsUnwindTableEntry()) 1053 return CFISection::EH; 1054 1055 if (MMI->hasDebugInfo() || TM.Options.ForceDwarfFrameSection) 1056 return CFISection::Debug; 1057 1058 return CFISection::None; 1059} 1060 1061AsmPrinter::CFISection 1062AsmPrinter::getFunctionCFISectionType(const MachineFunction &MF) const { 1063 return getFunctionCFISectionType(MF.getFunction()); 1064} 1065 1066bool AsmPrinter::needsSEHMoves() { 1067 return MAI->usesWindowsCFI() && MF->getFunction().needsUnwindTableEntry(); 1068} 1069 1070bool AsmPrinter::needsCFIForDebug() const { 1071 return MAI->getExceptionHandlingType() == ExceptionHandling::None && 1072 MAI->doesUseCFIForDebug() && ModuleCFISection == CFISection::Debug; 1073} 1074 1075void AsmPrinter::emitCFIInstruction(const MachineInstr &MI) { 1076 ExceptionHandling ExceptionHandlingType = MAI->getExceptionHandlingType(); 1077 if (!needsCFIForDebug() && 1078 ExceptionHandlingType != ExceptionHandling::DwarfCFI && 1079 ExceptionHandlingType != ExceptionHandling::ARM) 1080 return; 1081 1082 if (getFunctionCFISectionType(*MF) == CFISection::None) 1083 return; 1084 1085 // If there is no "real" instruction following this CFI instruction, skip 1086 // emitting it; it would be beyond the end of the function's FDE range. 1087 auto *MBB = MI.getParent(); 1088 auto I = std::next(MI.getIterator()); 1089 while (I != MBB->end() && I->isTransient()) 1090 ++I; 1091 if (I == MBB->instr_end() && 1092 MBB->getReverseIterator() == MBB->getParent()->rbegin()) 1093 return; 1094 1095 const std::vector<MCCFIInstruction> &Instrs = MF->getFrameInstructions(); 1096 unsigned CFIIndex = MI.getOperand(0).getCFIIndex(); 1097 const MCCFIInstruction &CFI = Instrs[CFIIndex]; 1098 emitCFIInstruction(CFI); 1099} 1100 1101void AsmPrinter::emitFrameAlloc(const MachineInstr &MI) { 1102 // The operands are the MCSymbol and the frame offset of the allocation. 1103 MCSymbol *FrameAllocSym = MI.getOperand(0).getMCSymbol(); 1104 int FrameOffset = MI.getOperand(1).getImm(); 1105 1106 // Emit a symbol assignment. 1107 OutStreamer->emitAssignment(FrameAllocSym, 1108 MCConstantExpr::create(FrameOffset, OutContext)); 1109} 1110 1111/// Returns the BB metadata to be emitted in the .llvm_bb_addr_map section for a 1112/// given basic block. This can be used to capture more precise profile 1113/// information. We use the last 4 bits (LSBs) to encode the following 1114/// information: 1115/// * (1): set if return block (ret or tail call). 1116/// * (2): set if ends with a tail call. 1117/// * (3): set if exception handling (EH) landing pad. 1118/// * (4): set if the block can fall through to its next. 1119/// The remaining bits are zero. 1120static unsigned getBBAddrMapMetadata(const MachineBasicBlock &MBB) { 1121 const TargetInstrInfo *TII = MBB.getParent()->getSubtarget().getInstrInfo(); 1122 return ((unsigned)MBB.isReturnBlock()) | 1123 ((!MBB.empty() && TII->isTailCall(MBB.back())) << 1) | 1124 (MBB.isEHPad() << 2) | 1125 (const_cast<MachineBasicBlock &>(MBB).canFallThrough() << 3); 1126} 1127 1128void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) { 1129 MCSection *BBAddrMapSection = 1130 getObjFileLowering().getBBAddrMapSection(*MF.getSection()); 1131 assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized."); 1132 1133 const MCSymbol *FunctionSymbol = getFunctionBegin(); 1134 1135 OutStreamer->PushSection(); 1136 OutStreamer->SwitchSection(BBAddrMapSection); 1137 OutStreamer->emitSymbolValue(FunctionSymbol, getPointerSize()); 1138 // Emit the total number of basic blocks in this function. 1139 OutStreamer->emitULEB128IntValue(MF.size()); 1140 // Emit BB Information for each basic block in the funciton. 1141 for (const MachineBasicBlock &MBB : MF) { 1142 const MCSymbol *MBBSymbol = 1143 MBB.isEntryBlock() ? FunctionSymbol : MBB.getSymbol(); 1144 // Emit the basic block offset. 1145 emitLabelDifferenceAsULEB128(MBBSymbol, FunctionSymbol); 1146 // Emit the basic block size. When BBs have alignments, their size cannot 1147 // always be computed from their offsets. 1148 emitLabelDifferenceAsULEB128(MBB.getEndSymbol(), MBBSymbol); 1149 OutStreamer->emitULEB128IntValue(getBBAddrMapMetadata(MBB)); 1150 } 1151 OutStreamer->PopSection(); 1152} 1153 1154void AsmPrinter::emitPseudoProbe(const MachineInstr &MI) { 1155 auto GUID = MI.getOperand(0).getImm(); 1156 auto Index = MI.getOperand(1).getImm(); 1157 auto Type = MI.getOperand(2).getImm(); 1158 auto Attr = MI.getOperand(3).getImm(); 1159 DILocation *DebugLoc = MI.getDebugLoc(); 1160 PP->emitPseudoProbe(GUID, Index, Type, Attr, DebugLoc); 1161} 1162 1163void AsmPrinter::emitStackSizeSection(const MachineFunction &MF) { 1164 if (!MF.getTarget().Options.EmitStackSizeSection) 1165 return; 1166 1167 MCSection *StackSizeSection = 1168 getObjFileLowering().getStackSizesSection(*getCurrentSection()); 1169 if (!StackSizeSection) 1170 return; 1171 1172 const MachineFrameInfo &FrameInfo = MF.getFrameInfo(); 1173 // Don't emit functions with dynamic stack allocations. 1174 if (FrameInfo.hasVarSizedObjects()) 1175 return; 1176 1177 OutStreamer->PushSection(); 1178 OutStreamer->SwitchSection(StackSizeSection); 1179 1180 const MCSymbol *FunctionSymbol = getFunctionBegin(); 1181 uint64_t StackSize = FrameInfo.getStackSize(); 1182 OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize()); 1183 OutStreamer->emitULEB128IntValue(StackSize); 1184 1185 OutStreamer->PopSection(); 1186} 1187 1188void AsmPrinter::emitStackUsage(const MachineFunction &MF) { 1189 const std::string &OutputFilename = MF.getTarget().Options.StackUsageOutput; 1190 1191 // OutputFilename empty implies -fstack-usage is not passed. 1192 if (OutputFilename.empty()) 1193 return; 1194 1195 const MachineFrameInfo &FrameInfo = MF.getFrameInfo(); 1196 uint64_t StackSize = FrameInfo.getStackSize(); 1197 1198 if (StackUsageStream == nullptr) { 1199 std::error_code EC; 1200 StackUsageStream = 1201 std::make_unique<raw_fd_ostream>(OutputFilename, EC, sys::fs::OF_Text); 1202 if (EC) { 1203 errs() << "Could not open file: " << EC.message(); 1204 return; 1205 } 1206 } 1207 1208 *StackUsageStream << MF.getFunction().getParent()->getName(); 1209 if (const DISubprogram *DSP = MF.getFunction().getSubprogram()) 1210 *StackUsageStream << ':' << DSP->getLine(); 1211 1212 *StackUsageStream << ':' << MF.getName() << '\t' << StackSize << '\t'; 1213 if (FrameInfo.hasVarSizedObjects()) 1214 *StackUsageStream << "dynamic\n"; 1215 else 1216 *StackUsageStream << "static\n"; 1217} 1218 1219static bool needFuncLabelsForEHOrDebugInfo(const MachineFunction &MF) { 1220 MachineModuleInfo &MMI = MF.getMMI(); 1221 if (!MF.getLandingPads().empty() || MF.hasEHFunclets() || MMI.hasDebugInfo()) 1222 return true; 1223 1224 // We might emit an EH table that uses function begin and end labels even if 1225 // we don't have any landingpads. 1226 if (!MF.getFunction().hasPersonalityFn()) 1227 return false; 1228 return !isNoOpWithoutInvoke( 1229 classifyEHPersonality(MF.getFunction().getPersonalityFn())); 1230} 1231 1232/// EmitFunctionBody - This method emits the body and trailer for a 1233/// function. 1234void AsmPrinter::emitFunctionBody() { 1235 emitFunctionHeader(); 1236 1237 // Emit target-specific gunk before the function body. 1238 emitFunctionBodyStart(); 1239 1240 if (isVerbose()) { 1241 // Get MachineDominatorTree or compute it on the fly if it's unavailable 1242 MDT = getAnalysisIfAvailable<MachineDominatorTree>(); 1243 if (!MDT) { 1244 OwnedMDT = std::make_unique<MachineDominatorTree>(); 1245 OwnedMDT->getBase().recalculate(*MF); 1246 MDT = OwnedMDT.get(); 1247 } 1248 1249 // Get MachineLoopInfo or compute it on the fly if it's unavailable 1250 MLI = getAnalysisIfAvailable<MachineLoopInfo>(); 1251 if (!MLI) { 1252 OwnedMLI = std::make_unique<MachineLoopInfo>(); 1253 OwnedMLI->getBase().analyze(MDT->getBase()); 1254 MLI = OwnedMLI.get(); 1255 } 1256 } 1257 1258 // Print out code for the function. 1259 bool HasAnyRealCode = false; 1260 int NumInstsInFunction = 0; 1261 1262 bool CanDoExtraAnalysis = ORE->allowExtraAnalysis(DEBUG_TYPE); 1263 for (auto &MBB : *MF) { 1264 // Print a label for the basic block. 1265 emitBasicBlockStart(MBB); 1266 DenseMap<StringRef, unsigned> MnemonicCounts; 1267 for (auto &MI : MBB) { 1268 // Print the assembly for the instruction. 1269 if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() && 1270 !MI.isDebugInstr()) { 1271 HasAnyRealCode = true; 1272 ++NumInstsInFunction; 1273 } 1274 1275 // If there is a pre-instruction symbol, emit a label for it here. 1276 if (MCSymbol *S = MI.getPreInstrSymbol()) 1277 OutStreamer->emitLabel(S); 1278 1279 for (const HandlerInfo &HI : Handlers) { 1280 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 1281 HI.TimerGroupDescription, TimePassesIsEnabled); 1282 HI.Handler->beginInstruction(&MI); 1283 } 1284 1285 if (isVerbose()) 1286 emitComments(MI, OutStreamer->GetCommentOS()); 1287 1288 switch (MI.getOpcode()) { 1289 case TargetOpcode::CFI_INSTRUCTION: 1290 emitCFIInstruction(MI); 1291 break; 1292 case TargetOpcode::LOCAL_ESCAPE: 1293 emitFrameAlloc(MI); 1294 break; 1295 case TargetOpcode::ANNOTATION_LABEL: 1296 case TargetOpcode::EH_LABEL: 1297 case TargetOpcode::GC_LABEL: 1298 OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol()); 1299 break; 1300 case TargetOpcode::INLINEASM: 1301 case TargetOpcode::INLINEASM_BR: 1302 emitInlineAsm(&MI); 1303 break; 1304 case TargetOpcode::DBG_VALUE: 1305 case TargetOpcode::DBG_VALUE_LIST: 1306 if (isVerbose()) { 1307 if (!emitDebugValueComment(&MI, *this)) 1308 emitInstruction(&MI); 1309 } 1310 break; 1311 case TargetOpcode::DBG_INSTR_REF: 1312 // This instruction reference will have been resolved to a machine 1313 // location, and a nearby DBG_VALUE created. We can safely ignore 1314 // the instruction reference. 1315 break; 1316 case TargetOpcode::DBG_LABEL: 1317 if (isVerbose()) { 1318 if (!emitDebugLabelComment(&MI, *this)) 1319 emitInstruction(&MI); 1320 } 1321 break; 1322 case TargetOpcode::IMPLICIT_DEF: 1323 if (isVerbose()) emitImplicitDef(&MI); 1324 break; 1325 case TargetOpcode::KILL: 1326 if (isVerbose()) emitKill(&MI, *this); 1327 break; 1328 case TargetOpcode::PSEUDO_PROBE: 1329 emitPseudoProbe(MI); 1330 break; 1331 default: 1332 emitInstruction(&MI); 1333 if (CanDoExtraAnalysis) { 1334 MCInst MCI; 1335 MCI.setOpcode(MI.getOpcode()); 1336 auto Name = OutStreamer->getMnemonic(MCI); 1337 auto I = MnemonicCounts.insert({Name, 0u}); 1338 I.first->second++; 1339 } 1340 break; 1341 } 1342 1343 // If there is a post-instruction symbol, emit a label for it here. 1344 if (MCSymbol *S = MI.getPostInstrSymbol()) 1345 OutStreamer->emitLabel(S); 1346 1347 for (const HandlerInfo &HI : Handlers) { 1348 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 1349 HI.TimerGroupDescription, TimePassesIsEnabled); 1350 HI.Handler->endInstruction(); 1351 } 1352 } 1353 1354 // We must emit temporary symbol for the end of this basic block, if either 1355 // we have BBLabels enabled or if this basic blocks marks the end of a 1356 // section (except the section containing the entry basic block as the end 1357 // symbol for that section is CurrentFnEnd). 1358 if (MF->hasBBLabels() || 1359 (MAI->hasDotTypeDotSizeDirective() && MBB.isEndSection() && 1360 !MBB.sameSection(&MF->front()))) 1361 OutStreamer->emitLabel(MBB.getEndSymbol()); 1362 1363 if (MBB.isEndSection()) { 1364 // The size directive for the section containing the entry block is 1365 // handled separately by the function section. 1366 if (!MBB.sameSection(&MF->front())) { 1367 if (MAI->hasDotTypeDotSizeDirective()) { 1368 // Emit the size directive for the basic block section. 1369 const MCExpr *SizeExp = MCBinaryExpr::createSub( 1370 MCSymbolRefExpr::create(MBB.getEndSymbol(), OutContext), 1371 MCSymbolRefExpr::create(CurrentSectionBeginSym, OutContext), 1372 OutContext); 1373 OutStreamer->emitELFSize(CurrentSectionBeginSym, SizeExp); 1374 } 1375 MBBSectionRanges[MBB.getSectionIDNum()] = 1376 MBBSectionRange{CurrentSectionBeginSym, MBB.getEndSymbol()}; 1377 } 1378 } 1379 emitBasicBlockEnd(MBB); 1380 1381 if (CanDoExtraAnalysis) { 1382 // Skip empty blocks. 1383 if (MBB.empty()) 1384 continue; 1385 1386 MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionMix", 1387 MBB.begin()->getDebugLoc(), &MBB); 1388 1389 // Generate instruction mix remark. First, sort counts in descending order 1390 // by count and name. 1391 SmallVector<std::pair<StringRef, unsigned>, 128> MnemonicVec; 1392 for (auto &KV : MnemonicCounts) 1393 MnemonicVec.emplace_back(KV.first, KV.second); 1394 1395 sort(MnemonicVec, [](const std::pair<StringRef, unsigned> &A, 1396 const std::pair<StringRef, unsigned> &B) { 1397 if (A.second > B.second) 1398 return true; 1399 if (A.second == B.second) 1400 return StringRef(A.first) < StringRef(B.first); 1401 return false; 1402 }); 1403 R << "BasicBlock: " << ore::NV("BasicBlock", MBB.getName()) << "\n"; 1404 for (auto &KV : MnemonicVec) { 1405 auto Name = (Twine("INST_") + KV.first.trim()).str(); 1406 R << KV.first << ": " << ore::NV(Name, KV.second) << "\n"; 1407 } 1408 ORE->emit(R); 1409 } 1410 } 1411 1412 EmittedInsts += NumInstsInFunction; 1413 MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionCount", 1414 MF->getFunction().getSubprogram(), 1415 &MF->front()); 1416 R << ore::NV("NumInstructions", NumInstsInFunction) 1417 << " instructions in function"; 1418 ORE->emit(R); 1419 1420 // If the function is empty and the object file uses .subsections_via_symbols, 1421 // then we need to emit *something* to the function body to prevent the 1422 // labels from collapsing together. Just emit a noop. 1423 // Similarly, don't emit empty functions on Windows either. It can lead to 1424 // duplicate entries (two functions with the same RVA) in the Guard CF Table 1425 // after linking, causing the kernel not to load the binary: 1426 // https://developercommunity.visualstudio.com/content/problem/45366/vc-linker-creates-invalid-dll-with-clang-cl.html 1427 // FIXME: Hide this behind some API in e.g. MCAsmInfo or MCTargetStreamer. 1428 const Triple &TT = TM.getTargetTriple(); 1429 if (!HasAnyRealCode && (MAI->hasSubsectionsViaSymbols() || 1430 (TT.isOSWindows() && TT.isOSBinFormatCOFF()))) { 1431 MCInst Noop = MF->getSubtarget().getInstrInfo()->getNop(); 1432 1433 // Targets can opt-out of emitting the noop here by leaving the opcode 1434 // unspecified. 1435 if (Noop.getOpcode()) { 1436 OutStreamer->AddComment("avoids zero-length function"); 1437 emitNops(1); 1438 } 1439 } 1440 1441 // Switch to the original section in case basic block sections was used. 1442 OutStreamer->SwitchSection(MF->getSection()); 1443 1444 const Function &F = MF->getFunction(); 1445 for (const auto &BB : F) { 1446 if (!BB.hasAddressTaken()) 1447 continue; 1448 MCSymbol *Sym = GetBlockAddressSymbol(&BB); 1449 if (Sym->isDefined()) 1450 continue; 1451 OutStreamer->AddComment("Address of block that was removed by CodeGen"); 1452 OutStreamer->emitLabel(Sym); 1453 } 1454 1455 // Emit target-specific gunk after the function body. 1456 emitFunctionBodyEnd(); 1457 1458 if (needFuncLabelsForEHOrDebugInfo(*MF) || 1459 MAI->hasDotTypeDotSizeDirective()) { 1460 // Create a symbol for the end of function. 1461 CurrentFnEnd = createTempSymbol("func_end"); 1462 OutStreamer->emitLabel(CurrentFnEnd); 1463 } 1464 1465 // If the target wants a .size directive for the size of the function, emit 1466 // it. 1467 if (MAI->hasDotTypeDotSizeDirective()) { 1468 // We can get the size as difference between the function label and the 1469 // temp label. 1470 const MCExpr *SizeExp = MCBinaryExpr::createSub( 1471 MCSymbolRefExpr::create(CurrentFnEnd, OutContext), 1472 MCSymbolRefExpr::create(CurrentFnSymForSize, OutContext), OutContext); 1473 OutStreamer->emitELFSize(CurrentFnSym, SizeExp); 1474 } 1475 1476 for (const HandlerInfo &HI : Handlers) { 1477 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 1478 HI.TimerGroupDescription, TimePassesIsEnabled); 1479 HI.Handler->markFunctionEnd(); 1480 } 1481 1482 MBBSectionRanges[MF->front().getSectionIDNum()] = 1483 MBBSectionRange{CurrentFnBegin, CurrentFnEnd}; 1484 1485 // Print out jump tables referenced by the function. 1486 emitJumpTableInfo(); 1487 1488 // Emit post-function debug and/or EH information. 1489 for (const HandlerInfo &HI : Handlers) { 1490 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 1491 HI.TimerGroupDescription, TimePassesIsEnabled); 1492 HI.Handler->endFunction(MF); 1493 } 1494 1495 // Emit section containing BB address offsets and their metadata, when 1496 // BB labels are requested for this function. Skip empty functions. 1497 if (MF->hasBBLabels() && HasAnyRealCode) 1498 emitBBAddrMapSection(*MF); 1499 1500 // Emit section containing stack size metadata. 1501 emitStackSizeSection(*MF); 1502 1503 // Emit .su file containing function stack size information. 1504 emitStackUsage(*MF); 1505 1506 emitPatchableFunctionEntries(); 1507 1508 if (isVerbose()) 1509 OutStreamer->GetCommentOS() << "-- End function\n"; 1510 1511 OutStreamer->AddBlankLine(); 1512} 1513 1514/// Compute the number of Global Variables that uses a Constant. 1515static unsigned getNumGlobalVariableUses(const Constant *C) { 1516 if (!C) 1517 return 0; 1518 1519 if (isa<GlobalVariable>(C)) 1520 return 1; 1521 1522 unsigned NumUses = 0; 1523 for (auto *CU : C->users()) 1524 NumUses += getNumGlobalVariableUses(dyn_cast<Constant>(CU)); 1525 1526 return NumUses; 1527} 1528 1529/// Only consider global GOT equivalents if at least one user is a 1530/// cstexpr inside an initializer of another global variables. Also, don't 1531/// handle cstexpr inside instructions. During global variable emission, 1532/// candidates are skipped and are emitted later in case at least one cstexpr 1533/// isn't replaced by a PC relative GOT entry access. 1534static bool isGOTEquivalentCandidate(const GlobalVariable *GV, 1535 unsigned &NumGOTEquivUsers) { 1536 // Global GOT equivalents are unnamed private globals with a constant 1537 // pointer initializer to another global symbol. They must point to a 1538 // GlobalVariable or Function, i.e., as GlobalValue. 1539 if (!GV->hasGlobalUnnamedAddr() || !GV->hasInitializer() || 1540 !GV->isConstant() || !GV->isDiscardableIfUnused() || 1541 !isa<GlobalValue>(GV->getOperand(0))) 1542 return false; 1543 1544 // To be a got equivalent, at least one of its users need to be a constant 1545 // expression used by another global variable. 1546 for (auto *U : GV->users()) 1547 NumGOTEquivUsers += getNumGlobalVariableUses(dyn_cast<Constant>(U)); 1548 1549 return NumGOTEquivUsers > 0; 1550} 1551 1552/// Unnamed constant global variables solely contaning a pointer to 1553/// another globals variable is equivalent to a GOT table entry; it contains the 1554/// the address of another symbol. Optimize it and replace accesses to these 1555/// "GOT equivalents" by using the GOT entry for the final global instead. 1556/// Compute GOT equivalent candidates among all global variables to avoid 1557/// emitting them if possible later on, after it use is replaced by a GOT entry 1558/// access. 1559void AsmPrinter::computeGlobalGOTEquivs(Module &M) { 1560 if (!getObjFileLowering().supportIndirectSymViaGOTPCRel()) 1561 return; 1562 1563 for (const auto &G : M.globals()) { 1564 unsigned NumGOTEquivUsers = 0; 1565 if (!isGOTEquivalentCandidate(&G, NumGOTEquivUsers)) 1566 continue; 1567 1568 const MCSymbol *GOTEquivSym = getSymbol(&G); 1569 GlobalGOTEquivs[GOTEquivSym] = std::make_pair(&G, NumGOTEquivUsers); 1570 } 1571} 1572 1573/// Constant expressions using GOT equivalent globals may not be eligible 1574/// for PC relative GOT entry conversion, in such cases we need to emit such 1575/// globals we previously omitted in EmitGlobalVariable. 1576void AsmPrinter::emitGlobalGOTEquivs() { 1577 if (!getObjFileLowering().supportIndirectSymViaGOTPCRel()) 1578 return; 1579 1580 SmallVector<const GlobalVariable *, 8> FailedCandidates; 1581 for (auto &I : GlobalGOTEquivs) { 1582 const GlobalVariable *GV = I.second.first; 1583 unsigned Cnt = I.second.second; 1584 if (Cnt) 1585 FailedCandidates.push_back(GV); 1586 } 1587 GlobalGOTEquivs.clear(); 1588 1589 for (auto *GV : FailedCandidates) 1590 emitGlobalVariable(GV); 1591} 1592 1593void AsmPrinter::emitGlobalIndirectSymbol(Module &M, 1594 const GlobalIndirectSymbol& GIS) { 1595 MCSymbol *Name = getSymbol(&GIS); 1596 bool IsFunction = GIS.getValueType()->isFunctionTy(); 1597 // Treat bitcasts of functions as functions also. This is important at least 1598 // on WebAssembly where object and function addresses can't alias each other. 1599 if (!IsFunction) 1600 if (auto *CE = dyn_cast<ConstantExpr>(GIS.getIndirectSymbol())) 1601 if (CE->getOpcode() == Instruction::BitCast) 1602 IsFunction = 1603 CE->getOperand(0)->getType()->getPointerElementType()->isFunctionTy(); 1604 1605 // AIX's assembly directive `.set` is not usable for aliasing purpose, 1606 // so AIX has to use the extra-label-at-definition strategy. At this 1607 // point, all the extra label is emitted, we just have to emit linkage for 1608 // those labels. 1609 if (TM.getTargetTriple().isOSBinFormatXCOFF()) { 1610 assert(!isa<GlobalIFunc>(GIS) && "IFunc is not supported on AIX."); 1611 assert(MAI->hasVisibilityOnlyWithLinkage() && 1612 "Visibility should be handled with emitLinkage() on AIX."); 1613 emitLinkage(&GIS, Name); 1614 // If it's a function, also emit linkage for aliases of function entry 1615 // point. 1616 if (IsFunction) 1617 emitLinkage(&GIS, 1618 getObjFileLowering().getFunctionEntryPointSymbol(&GIS, TM)); 1619 return; 1620 } 1621 1622 if (GIS.hasExternalLinkage() || !MAI->getWeakRefDirective()) 1623 OutStreamer->emitSymbolAttribute(Name, MCSA_Global); 1624 else if (GIS.hasWeakLinkage() || GIS.hasLinkOnceLinkage()) 1625 OutStreamer->emitSymbolAttribute(Name, MCSA_WeakReference); 1626 else 1627 assert(GIS.hasLocalLinkage() && "Invalid alias or ifunc linkage"); 1628 1629 // Set the symbol type to function if the alias has a function type. 1630 // This affects codegen when the aliasee is not a function. 1631 if (IsFunction) 1632 OutStreamer->emitSymbolAttribute(Name, isa<GlobalIFunc>(GIS) 1633 ? MCSA_ELF_TypeIndFunction 1634 : MCSA_ELF_TypeFunction); 1635 1636 emitVisibility(Name, GIS.getVisibility()); 1637 1638 const MCExpr *Expr = lowerConstant(GIS.getIndirectSymbol()); 1639 1640 if (isa<GlobalAlias>(&GIS) && MAI->hasAltEntry() && isa<MCBinaryExpr>(Expr)) 1641 OutStreamer->emitSymbolAttribute(Name, MCSA_AltEntry); 1642 1643 // Emit the directives as assignments aka .set: 1644 OutStreamer->emitAssignment(Name, Expr); 1645 MCSymbol *LocalAlias = getSymbolPreferLocal(GIS); 1646 if (LocalAlias != Name) 1647 OutStreamer->emitAssignment(LocalAlias, Expr); 1648 1649 if (auto *GA = dyn_cast<GlobalAlias>(&GIS)) { 1650 // If the aliasee does not correspond to a symbol in the output, i.e. the 1651 // alias is not of an object or the aliased object is private, then set the 1652 // size of the alias symbol from the type of the alias. We don't do this in 1653 // other situations as the alias and aliasee having differing types but same 1654 // size may be intentional. 1655 const GlobalObject *BaseObject = GA->getBaseObject(); 1656 if (MAI->hasDotTypeDotSizeDirective() && GA->getValueType()->isSized() && 1657 (!BaseObject || BaseObject->hasPrivateLinkage())) { 1658 const DataLayout &DL = M.getDataLayout(); 1659 uint64_t Size = DL.getTypeAllocSize(GA->getValueType()); 1660 OutStreamer->emitELFSize(Name, MCConstantExpr::create(Size, OutContext)); 1661 } 1662 } 1663} 1664 1665void AsmPrinter::emitRemarksSection(remarks::RemarkStreamer &RS) { 1666 if (!RS.needsSection()) 1667 return; 1668 1669 remarks::RemarkSerializer &RemarkSerializer = RS.getSerializer(); 1670 1671 Optional<SmallString<128>> Filename; 1672 if (Optional<StringRef> FilenameRef = RS.getFilename()) { 1673 Filename = *FilenameRef; 1674 sys::fs::make_absolute(*Filename); 1675 assert(!Filename->empty() && "The filename can't be empty."); 1676 } 1677 1678 std::string Buf; 1679 raw_string_ostream OS(Buf); 1680 std::unique_ptr<remarks::MetaSerializer> MetaSerializer = 1681 Filename ? RemarkSerializer.metaSerializer(OS, StringRef(*Filename)) 1682 : RemarkSerializer.metaSerializer(OS); 1683 MetaSerializer->emit(); 1684 1685 // Switch to the remarks section. 1686 MCSection *RemarksSection = 1687 OutContext.getObjectFileInfo()->getRemarksSection(); 1688 OutStreamer->SwitchSection(RemarksSection); 1689 1690 OutStreamer->emitBinaryData(OS.str()); 1691} 1692 1693bool AsmPrinter::doFinalization(Module &M) { 1694 // Set the MachineFunction to nullptr so that we can catch attempted 1695 // accesses to MF specific features at the module level and so that 1696 // we can conditionalize accesses based on whether or not it is nullptr. 1697 MF = nullptr; 1698 1699 // Gather all GOT equivalent globals in the module. We really need two 1700 // passes over the globals: one to compute and another to avoid its emission 1701 // in EmitGlobalVariable, otherwise we would not be able to handle cases 1702 // where the got equivalent shows up before its use. 1703 computeGlobalGOTEquivs(M); 1704 1705 // Emit global variables. 1706 for (const auto &G : M.globals()) 1707 emitGlobalVariable(&G); 1708 1709 // Emit remaining GOT equivalent globals. 1710 emitGlobalGOTEquivs(); 1711 1712 const TargetLoweringObjectFile &TLOF = getObjFileLowering(); 1713 1714 // Emit linkage(XCOFF) and visibility info for declarations 1715 for (const Function &F : M) { 1716 if (!F.isDeclarationForLinker()) 1717 continue; 1718 1719 MCSymbol *Name = getSymbol(&F); 1720 // Function getSymbol gives us the function descriptor symbol for XCOFF. 1721 1722 if (!TM.getTargetTriple().isOSBinFormatXCOFF()) { 1723 GlobalValue::VisibilityTypes V = F.getVisibility(); 1724 if (V == GlobalValue::DefaultVisibility) 1725 continue; 1726 1727 emitVisibility(Name, V, false); 1728 continue; 1729 } 1730 1731 if (F.isIntrinsic()) 1732 continue; 1733 1734 // Handle the XCOFF case. 1735 // Variable `Name` is the function descriptor symbol (see above). Get the 1736 // function entry point symbol. 1737 MCSymbol *FnEntryPointSym = TLOF.getFunctionEntryPointSymbol(&F, TM); 1738 // Emit linkage for the function entry point. 1739 emitLinkage(&F, FnEntryPointSym); 1740 1741 // Emit linkage for the function descriptor. 1742 emitLinkage(&F, Name); 1743 } 1744 1745 // Emit the remarks section contents. 1746 // FIXME: Figure out when is the safest time to emit this section. It should 1747 // not come after debug info. 1748 if (remarks::RemarkStreamer *RS = M.getContext().getMainRemarkStreamer()) 1749 emitRemarksSection(*RS); 1750 1751 TLOF.emitModuleMetadata(*OutStreamer, M); 1752 1753 if (TM.getTargetTriple().isOSBinFormatELF()) { 1754 MachineModuleInfoELF &MMIELF = MMI->getObjFileInfo<MachineModuleInfoELF>(); 1755 1756 // Output stubs for external and common global variables. 1757 MachineModuleInfoELF::SymbolListTy Stubs = MMIELF.GetGVStubList(); 1758 if (!Stubs.empty()) { 1759 OutStreamer->SwitchSection(TLOF.getDataSection()); 1760 const DataLayout &DL = M.getDataLayout(); 1761 1762 emitAlignment(Align(DL.getPointerSize())); 1763 for (const auto &Stub : Stubs) { 1764 OutStreamer->emitLabel(Stub.first); 1765 OutStreamer->emitSymbolValue(Stub.second.getPointer(), 1766 DL.getPointerSize()); 1767 } 1768 } 1769 } 1770 1771 if (TM.getTargetTriple().isOSBinFormatCOFF()) { 1772 MachineModuleInfoCOFF &MMICOFF = 1773 MMI->getObjFileInfo<MachineModuleInfoCOFF>(); 1774 1775 // Output stubs for external and common global variables. 1776 MachineModuleInfoCOFF::SymbolListTy Stubs = MMICOFF.GetGVStubList(); 1777 if (!Stubs.empty()) { 1778 const DataLayout &DL = M.getDataLayout(); 1779 1780 for (const auto &Stub : Stubs) { 1781 SmallString<256> SectionName = StringRef(".rdata$"); 1782 SectionName += Stub.first->getName(); 1783 OutStreamer->SwitchSection(OutContext.getCOFFSection( 1784 SectionName, 1785 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ | 1786 COFF::IMAGE_SCN_LNK_COMDAT, 1787 SectionKind::getReadOnly(), Stub.first->getName(), 1788 COFF::IMAGE_COMDAT_SELECT_ANY)); 1789 emitAlignment(Align(DL.getPointerSize())); 1790 OutStreamer->emitSymbolAttribute(Stub.first, MCSA_Global); 1791 OutStreamer->emitLabel(Stub.first); 1792 OutStreamer->emitSymbolValue(Stub.second.getPointer(), 1793 DL.getPointerSize()); 1794 } 1795 } 1796 } 1797 1798 // Finalize debug and EH information. 1799 for (const HandlerInfo &HI : Handlers) { 1800 NamedRegionTimer T(HI.TimerName, HI.TimerDescription, HI.TimerGroupName, 1801 HI.TimerGroupDescription, TimePassesIsEnabled); 1802 HI.Handler->endModule(); 1803 } 1804 1805 // This deletes all the ephemeral handlers that AsmPrinter added, while 1806 // keeping all the user-added handlers alive until the AsmPrinter is 1807 // destroyed. 1808 Handlers.erase(Handlers.begin() + NumUserHandlers, Handlers.end()); 1809 DD = nullptr; 1810 1811 // If the target wants to know about weak references, print them all. 1812 if (MAI->getWeakRefDirective()) { 1813 // FIXME: This is not lazy, it would be nice to only print weak references 1814 // to stuff that is actually used. Note that doing so would require targets 1815 // to notice uses in operands (due to constant exprs etc). This should 1816 // happen with the MC stuff eventually. 1817 1818 // Print out module-level global objects here. 1819 for (const auto &GO : M.global_objects()) { 1820 if (!GO.hasExternalWeakLinkage()) 1821 continue; 1822 OutStreamer->emitSymbolAttribute(getSymbol(&GO), MCSA_WeakReference); 1823 } 1824 } 1825 1826 // Print aliases in topological order, that is, for each alias a = b, 1827 // b must be printed before a. 1828 // This is because on some targets (e.g. PowerPC) linker expects aliases in 1829 // such an order to generate correct TOC information. 1830 SmallVector<const GlobalAlias *, 16> AliasStack; 1831 SmallPtrSet<const GlobalAlias *, 16> AliasVisited; 1832 for (const auto &Alias : M.aliases()) { 1833 for (const GlobalAlias *Cur = &Alias; Cur; 1834 Cur = dyn_cast<GlobalAlias>(Cur->getAliasee())) { 1835 if (!AliasVisited.insert(Cur).second) 1836 break; 1837 AliasStack.push_back(Cur); 1838 } 1839 for (const GlobalAlias *AncestorAlias : llvm::reverse(AliasStack)) 1840 emitGlobalIndirectSymbol(M, *AncestorAlias); 1841 AliasStack.clear(); 1842 } 1843 for (const auto &IFunc : M.ifuncs()) 1844 emitGlobalIndirectSymbol(M, IFunc); 1845 1846 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 1847 assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 1848 for (GCModuleInfo::iterator I = MI->end(), E = MI->begin(); I != E; ) 1849 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(**--I)) 1850 MP->finishAssembly(M, *MI, *this); 1851 1852 // Emit llvm.ident metadata in an '.ident' directive. 1853 emitModuleIdents(M); 1854 1855 // Emit bytes for llvm.commandline metadata. 1856 emitModuleCommandLines(M); 1857 1858 // Emit __morestack address if needed for indirect calls. 1859 if (MMI->usesMorestackAddr()) { 1860 Align Alignment(1); 1861 MCSection *ReadOnlySection = getObjFileLowering().getSectionForConstant( 1862 getDataLayout(), SectionKind::getReadOnly(), 1863 /*C=*/nullptr, Alignment); 1864 OutStreamer->SwitchSection(ReadOnlySection); 1865 1866 MCSymbol *AddrSymbol = 1867 OutContext.getOrCreateSymbol(StringRef("__morestack_addr")); 1868 OutStreamer->emitLabel(AddrSymbol); 1869 1870 unsigned PtrSize = MAI->getCodePointerSize(); 1871 OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("__morestack"), 1872 PtrSize); 1873 } 1874 1875 // Emit .note.GNU-split-stack and .note.GNU-no-split-stack sections if 1876 // split-stack is used. 1877 if (TM.getTargetTriple().isOSBinFormatELF() && MMI->hasSplitStack()) { 1878 OutStreamer->SwitchSection( 1879 OutContext.getELFSection(".note.GNU-split-stack", ELF::SHT_PROGBITS, 0)); 1880 if (MMI->hasNosplitStack()) 1881 OutStreamer->SwitchSection( 1882 OutContext.getELFSection(".note.GNU-no-split-stack", ELF::SHT_PROGBITS, 0)); 1883 } 1884 1885 // If we don't have any trampolines, then we don't require stack memory 1886 // to be executable. Some targets have a directive to declare this. 1887 Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline"); 1888 if (!InitTrampolineIntrinsic || InitTrampolineIntrinsic->use_empty()) 1889 if (MCSection *S = MAI->getNonexecutableStackSection(OutContext)) 1890 OutStreamer->SwitchSection(S); 1891 1892 if (TM.Options.EmitAddrsig) { 1893 // Emit address-significance attributes for all globals. 1894 OutStreamer->emitAddrsig(); 1895 for (const GlobalValue &GV : M.global_values()) { 1896 if (!GV.use_empty() && !GV.isTransitiveUsedByMetadataOnly() && 1897 !GV.isThreadLocal() && !GV.hasDLLImportStorageClass() && 1898 !GV.getName().startswith("llvm.") && !GV.hasAtLeastLocalUnnamedAddr()) 1899 OutStreamer->emitAddrsigSym(getSymbol(&GV)); 1900 } 1901 } 1902 1903 // Emit symbol partition specifications (ELF only). 1904 if (TM.getTargetTriple().isOSBinFormatELF()) { 1905 unsigned UniqueID = 0; 1906 for (const GlobalValue &GV : M.global_values()) { 1907 if (!GV.hasPartition() || GV.isDeclarationForLinker() || 1908 GV.getVisibility() != GlobalValue::DefaultVisibility) 1909 continue; 1910 1911 OutStreamer->SwitchSection( 1912 OutContext.getELFSection(".llvm_sympart", ELF::SHT_LLVM_SYMPART, 0, 0, 1913 "", false, ++UniqueID, nullptr)); 1914 OutStreamer->emitBytes(GV.getPartition()); 1915 OutStreamer->emitZeros(1); 1916 OutStreamer->emitValue( 1917 MCSymbolRefExpr::create(getSymbol(&GV), OutContext), 1918 MAI->getCodePointerSize()); 1919 } 1920 } 1921 1922 // Allow the target to emit any magic that it wants at the end of the file, 1923 // after everything else has gone out. 1924 emitEndOfAsmFile(M); 1925 1926 MMI = nullptr; 1927 1928 OutStreamer->Finish(); 1929 OutStreamer->reset(); 1930 OwnedMLI.reset(); 1931 OwnedMDT.reset(); 1932 1933 return false; 1934} 1935 1936MCSymbol *AsmPrinter::getMBBExceptionSym(const MachineBasicBlock &MBB) { 1937 auto Res = MBBSectionExceptionSyms.try_emplace(MBB.getSectionIDNum()); 1938 if (Res.second) 1939 Res.first->second = createTempSymbol("exception"); 1940 return Res.first->second; 1941} 1942 1943void AsmPrinter::SetupMachineFunction(MachineFunction &MF) { 1944 this->MF = &MF; 1945 const Function &F = MF.getFunction(); 1946 1947 // Get the function symbol. 1948 if (!MAI->needsFunctionDescriptors()) { 1949 CurrentFnSym = getSymbol(&MF.getFunction()); 1950 } else { 1951 assert(TM.getTargetTriple().isOSAIX() && 1952 "Only AIX uses the function descriptor hooks."); 1953 // AIX is unique here in that the name of the symbol emitted for the 1954 // function body does not have the same name as the source function's 1955 // C-linkage name. 1956 assert(CurrentFnDescSym && "The function descriptor symbol needs to be" 1957 " initalized first."); 1958 1959 // Get the function entry point symbol. 1960 CurrentFnSym = getObjFileLowering().getFunctionEntryPointSymbol(&F, TM); 1961 } 1962 1963 CurrentFnSymForSize = CurrentFnSym; 1964 CurrentFnBegin = nullptr; 1965 CurrentSectionBeginSym = nullptr; 1966 MBBSectionRanges.clear(); 1967 MBBSectionExceptionSyms.clear(); 1968 bool NeedsLocalForSize = MAI->needsLocalForSize(); 1969 if (F.hasFnAttribute("patchable-function-entry") || 1970 F.hasFnAttribute("function-instrument") || 1971 F.hasFnAttribute("xray-instruction-threshold") || 1972 needFuncLabelsForEHOrDebugInfo(MF) || NeedsLocalForSize || 1973 MF.getTarget().Options.EmitStackSizeSection || MF.hasBBLabels()) { 1974 CurrentFnBegin = createTempSymbol("func_begin"); 1975 if (NeedsLocalForSize) 1976 CurrentFnSymForSize = CurrentFnBegin; 1977 } 1978 1979 ORE = &getAnalysis<MachineOptimizationRemarkEmitterPass>().getORE(); 1980} 1981 1982namespace { 1983 1984// Keep track the alignment, constpool entries per Section. 1985 struct SectionCPs { 1986 MCSection *S; 1987 Align Alignment; 1988 SmallVector<unsigned, 4> CPEs; 1989 1990 SectionCPs(MCSection *s, Align a) : S(s), Alignment(a) {} 1991 }; 1992 1993} // end anonymous namespace 1994 1995/// EmitConstantPool - Print to the current output stream assembly 1996/// representations of the constants in the constant pool MCP. This is 1997/// used to print out constants which have been "spilled to memory" by 1998/// the code generator. 1999void AsmPrinter::emitConstantPool() { 2000 const MachineConstantPool *MCP = MF->getConstantPool(); 2001 const std::vector<MachineConstantPoolEntry> &CP = MCP->getConstants(); 2002 if (CP.empty()) return; 2003 2004 // Calculate sections for constant pool entries. We collect entries to go into 2005 // the same section together to reduce amount of section switch statements. 2006 SmallVector<SectionCPs, 4> CPSections; 2007 for (unsigned i = 0, e = CP.size(); i != e; ++i) { 2008 const MachineConstantPoolEntry &CPE = CP[i]; 2009 Align Alignment = CPE.getAlign(); 2010 2011 SectionKind Kind = CPE.getSectionKind(&getDataLayout()); 2012 2013 const Constant *C = nullptr; 2014 if (!CPE.isMachineConstantPoolEntry()) 2015 C = CPE.Val.ConstVal; 2016 2017 MCSection *S = getObjFileLowering().getSectionForConstant( 2018 getDataLayout(), Kind, C, Alignment); 2019 2020 // The number of sections are small, just do a linear search from the 2021 // last section to the first. 2022 bool Found = false; 2023 unsigned SecIdx = CPSections.size(); 2024 while (SecIdx != 0) { 2025 if (CPSections[--SecIdx].S == S) { 2026 Found = true; 2027 break; 2028 } 2029 } 2030 if (!Found) { 2031 SecIdx = CPSections.size(); 2032 CPSections.push_back(SectionCPs(S, Alignment)); 2033 } 2034 2035 if (Alignment > CPSections[SecIdx].Alignment) 2036 CPSections[SecIdx].Alignment = Alignment; 2037 CPSections[SecIdx].CPEs.push_back(i); 2038 } 2039 2040 // Now print stuff into the calculated sections. 2041 const MCSection *CurSection = nullptr; 2042 unsigned Offset = 0; 2043 for (unsigned i = 0, e = CPSections.size(); i != e; ++i) { 2044 for (unsigned j = 0, ee = CPSections[i].CPEs.size(); j != ee; ++j) { 2045 unsigned CPI = CPSections[i].CPEs[j]; 2046 MCSymbol *Sym = GetCPISymbol(CPI); 2047 if (!Sym->isUndefined()) 2048 continue; 2049 2050 if (CurSection != CPSections[i].S) { 2051 OutStreamer->SwitchSection(CPSections[i].S); 2052 emitAlignment(Align(CPSections[i].Alignment)); 2053 CurSection = CPSections[i].S; 2054 Offset = 0; 2055 } 2056 2057 MachineConstantPoolEntry CPE = CP[CPI]; 2058 2059 // Emit inter-object padding for alignment. 2060 unsigned NewOffset = alignTo(Offset, CPE.getAlign()); 2061 OutStreamer->emitZeros(NewOffset - Offset); 2062 2063 Offset = NewOffset + CPE.getSizeInBytes(getDataLayout()); 2064 2065 OutStreamer->emitLabel(Sym); 2066 if (CPE.isMachineConstantPoolEntry()) 2067 emitMachineConstantPoolValue(CPE.Val.MachineCPVal); 2068 else 2069 emitGlobalConstant(getDataLayout(), CPE.Val.ConstVal); 2070 } 2071 } 2072} 2073 2074// Print assembly representations of the jump tables used by the current 2075// function. 2076void AsmPrinter::emitJumpTableInfo() { 2077 const DataLayout &DL = MF->getDataLayout(); 2078 const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); 2079 if (!MJTI) return; 2080 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_Inline) return; 2081 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 2082 if (JT.empty()) return; 2083 2084 // Pick the directive to use to print the jump table entries, and switch to 2085 // the appropriate section. 2086 const Function &F = MF->getFunction(); 2087 const TargetLoweringObjectFile &TLOF = getObjFileLowering(); 2088 bool JTInDiffSection = !TLOF.shouldPutJumpTableInFunctionSection( 2089 MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32, 2090 F); 2091 if (JTInDiffSection) { 2092 // Drop it in the readonly section. 2093 MCSection *ReadOnlySection = TLOF.getSectionForJumpTable(F, TM); 2094 OutStreamer->SwitchSection(ReadOnlySection); 2095 } 2096 2097 emitAlignment(Align(MJTI->getEntryAlignment(DL))); 2098 2099 // Jump tables in code sections are marked with a data_region directive 2100 // where that's supported. 2101 if (!JTInDiffSection) 2102 OutStreamer->emitDataRegion(MCDR_DataRegionJT32); 2103 2104 for (unsigned JTI = 0, e = JT.size(); JTI != e; ++JTI) { 2105 const std::vector<MachineBasicBlock*> &JTBBs = JT[JTI].MBBs; 2106 2107 // If this jump table was deleted, ignore it. 2108 if (JTBBs.empty()) continue; 2109 2110 // For the EK_LabelDifference32 entry, if using .set avoids a relocation, 2111 /// emit a .set directive for each unique entry. 2112 if (MJTI->getEntryKind() == MachineJumpTableInfo::EK_LabelDifference32 && 2113 MAI->doesSetDirectiveSuppressReloc()) { 2114 SmallPtrSet<const MachineBasicBlock*, 16> EmittedSets; 2115 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering(); 2116 const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF,JTI,OutContext); 2117 for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) { 2118 const MachineBasicBlock *MBB = JTBBs[ii]; 2119 if (!EmittedSets.insert(MBB).second) 2120 continue; 2121 2122 // .set LJTSet, LBB32-base 2123 const MCExpr *LHS = 2124 MCSymbolRefExpr::create(MBB->getSymbol(), OutContext); 2125 OutStreamer->emitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()), 2126 MCBinaryExpr::createSub(LHS, Base, 2127 OutContext)); 2128 } 2129 } 2130 2131 // On some targets (e.g. Darwin) we want to emit two consecutive labels 2132 // before each jump table. The first label is never referenced, but tells 2133 // the assembler and linker the extents of the jump table object. The 2134 // second label is actually referenced by the code. 2135 if (JTInDiffSection && DL.hasLinkerPrivateGlobalPrefix()) 2136 // FIXME: This doesn't have to have any specific name, just any randomly 2137 // named and numbered local label started with 'l' would work. Simplify 2138 // GetJTISymbol. 2139 OutStreamer->emitLabel(GetJTISymbol(JTI, true)); 2140 2141 MCSymbol* JTISymbol = GetJTISymbol(JTI); 2142 OutStreamer->emitLabel(JTISymbol); 2143 2144 for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) 2145 emitJumpTableEntry(MJTI, JTBBs[ii], JTI); 2146 } 2147 if (!JTInDiffSection) 2148 OutStreamer->emitDataRegion(MCDR_DataRegionEnd); 2149} 2150 2151/// EmitJumpTableEntry - Emit a jump table entry for the specified MBB to the 2152/// current stream. 2153void AsmPrinter::emitJumpTableEntry(const MachineJumpTableInfo *MJTI, 2154 const MachineBasicBlock *MBB, 2155 unsigned UID) const { 2156 assert(MBB && MBB->getNumber() >= 0 && "Invalid basic block"); 2157 const MCExpr *Value = nullptr; 2158 switch (MJTI->getEntryKind()) { 2159 case MachineJumpTableInfo::EK_Inline: 2160 llvm_unreachable("Cannot emit EK_Inline jump table entry"); 2161 case MachineJumpTableInfo::EK_Custom32: 2162 Value = MF->getSubtarget().getTargetLowering()->LowerCustomJumpTableEntry( 2163 MJTI, MBB, UID, OutContext); 2164 break; 2165 case MachineJumpTableInfo::EK_BlockAddress: 2166 // EK_BlockAddress - Each entry is a plain address of block, e.g.: 2167 // .word LBB123 2168 Value = MCSymbolRefExpr::create(MBB->getSymbol(), OutContext); 2169 break; 2170 case MachineJumpTableInfo::EK_GPRel32BlockAddress: { 2171 // EK_GPRel32BlockAddress - Each entry is an address of block, encoded 2172 // with a relocation as gp-relative, e.g.: 2173 // .gprel32 LBB123 2174 MCSymbol *MBBSym = MBB->getSymbol(); 2175 OutStreamer->emitGPRel32Value(MCSymbolRefExpr::create(MBBSym, OutContext)); 2176 return; 2177 } 2178 2179 case MachineJumpTableInfo::EK_GPRel64BlockAddress: { 2180 // EK_GPRel64BlockAddress - Each entry is an address of block, encoded 2181 // with a relocation as gp-relative, e.g.: 2182 // .gpdword LBB123 2183 MCSymbol *MBBSym = MBB->getSymbol(); 2184 OutStreamer->emitGPRel64Value(MCSymbolRefExpr::create(MBBSym, OutContext)); 2185 return; 2186 } 2187 2188 case MachineJumpTableInfo::EK_LabelDifference32: { 2189 // Each entry is the address of the block minus the address of the jump 2190 // table. This is used for PIC jump tables where gprel32 is not supported. 2191 // e.g.: 2192 // .word LBB123 - LJTI1_2 2193 // If the .set directive avoids relocations, this is emitted as: 2194 // .set L4_5_set_123, LBB123 - LJTI1_2 2195 // .word L4_5_set_123 2196 if (MAI->doesSetDirectiveSuppressReloc()) { 2197 Value = MCSymbolRefExpr::create(GetJTSetSymbol(UID, MBB->getNumber()), 2198 OutContext); 2199 break; 2200 } 2201 Value = MCSymbolRefExpr::create(MBB->getSymbol(), OutContext); 2202 const TargetLowering *TLI = MF->getSubtarget().getTargetLowering(); 2203 const MCExpr *Base = TLI->getPICJumpTableRelocBaseExpr(MF, UID, OutContext); 2204 Value = MCBinaryExpr::createSub(Value, Base, OutContext); 2205 break; 2206 } 2207 } 2208 2209 assert(Value && "Unknown entry kind!"); 2210 2211 unsigned EntrySize = MJTI->getEntrySize(getDataLayout()); 2212 OutStreamer->emitValue(Value, EntrySize); 2213} 2214 2215/// EmitSpecialLLVMGlobal - Check to see if the specified global is a 2216/// special global used by LLVM. If so, emit it and return true, otherwise 2217/// do nothing and return false. 2218bool AsmPrinter::emitSpecialLLVMGlobal(const GlobalVariable *GV) { 2219 if (GV->getName() == "llvm.used") { 2220 if (MAI->hasNoDeadStrip()) // No need to emit this at all. 2221 emitLLVMUsedList(cast<ConstantArray>(GV->getInitializer())); 2222 return true; 2223 } 2224 2225 // Ignore debug and non-emitted data. This handles llvm.compiler.used. 2226 if (GV->getSection() == "llvm.metadata" || 2227 GV->hasAvailableExternallyLinkage()) 2228 return true; 2229 2230 if (!GV->hasAppendingLinkage()) return false; 2231 2232 assert(GV->hasInitializer() && "Not a special LLVM global!"); 2233 2234 if (GV->getName() == "llvm.global_ctors") { 2235 emitXXStructorList(GV->getParent()->getDataLayout(), GV->getInitializer(), 2236 /* isCtor */ true); 2237 2238 return true; 2239 } 2240 2241 if (GV->getName() == "llvm.global_dtors") { 2242 emitXXStructorList(GV->getParent()->getDataLayout(), GV->getInitializer(), 2243 /* isCtor */ false); 2244 2245 return true; 2246 } 2247 2248 report_fatal_error("unknown special variable"); 2249} 2250 2251/// EmitLLVMUsedList - For targets that define a MAI::UsedDirective, mark each 2252/// global in the specified llvm.used list. 2253void AsmPrinter::emitLLVMUsedList(const ConstantArray *InitList) { 2254 // Should be an array of 'i8*'. 2255 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) { 2256 const GlobalValue *GV = 2257 dyn_cast<GlobalValue>(InitList->getOperand(i)->stripPointerCasts()); 2258 if (GV) 2259 OutStreamer->emitSymbolAttribute(getSymbol(GV), MCSA_NoDeadStrip); 2260 } 2261} 2262 2263void AsmPrinter::preprocessXXStructorList(const DataLayout &DL, 2264 const Constant *List, 2265 SmallVector<Structor, 8> &Structors) { 2266 // Should be an array of '{ i32, void ()*, i8* }' structs. The first value is 2267 // the init priority. 2268 if (!isa<ConstantArray>(List)) 2269 return; 2270 2271 // Gather the structors in a form that's convenient for sorting by priority. 2272 for (Value *O : cast<ConstantArray>(List)->operands()) { 2273 auto *CS = cast<ConstantStruct>(O); 2274 if (CS->getOperand(1)->isNullValue()) 2275 break; // Found a null terminator, skip the rest. 2276 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0)); 2277 if (!Priority) 2278 continue; // Malformed. 2279 Structors.push_back(Structor()); 2280 Structor &S = Structors.back(); 2281 S.Priority = Priority->getLimitedValue(65535); 2282 S.Func = CS->getOperand(1); 2283 if (!CS->getOperand(2)->isNullValue()) { 2284 if (TM.getTargetTriple().isOSAIX()) 2285 llvm::report_fatal_error( 2286 "associated data of XXStructor list is not yet supported on AIX"); 2287 S.ComdatKey = 2288 dyn_cast<GlobalValue>(CS->getOperand(2)->stripPointerCasts()); 2289 } 2290 } 2291 2292 // Emit the function pointers in the target-specific order 2293 llvm::stable_sort(Structors, [](const Structor &L, const Structor &R) { 2294 return L.Priority < R.Priority; 2295 }); 2296} 2297 2298/// EmitXXStructorList - Emit the ctor or dtor list taking into account the init 2299/// priority. 2300void AsmPrinter::emitXXStructorList(const DataLayout &DL, const Constant *List, 2301 bool IsCtor) { 2302 SmallVector<Structor, 8> Structors; 2303 preprocessXXStructorList(DL, List, Structors); 2304 if (Structors.empty()) 2305 return; 2306 2307 const Align Align = DL.getPointerPrefAlignment(); 2308 for (Structor &S : Structors) { 2309 const TargetLoweringObjectFile &Obj = getObjFileLowering(); 2310 const MCSymbol *KeySym = nullptr; 2311 if (GlobalValue *GV = S.ComdatKey) { 2312 if (GV->isDeclarationForLinker()) 2313 // If the associated variable is not defined in this module 2314 // (it might be available_externally, or have been an 2315 // available_externally definition that was dropped by the 2316 // EliminateAvailableExternally pass), some other TU 2317 // will provide its dynamic initializer. 2318 continue; 2319 2320 KeySym = getSymbol(GV); 2321 } 2322 2323 MCSection *OutputSection = 2324 (IsCtor ? Obj.getStaticCtorSection(S.Priority, KeySym) 2325 : Obj.getStaticDtorSection(S.Priority, KeySym)); 2326 OutStreamer->SwitchSection(OutputSection); 2327 if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection()) 2328 emitAlignment(Align); 2329 emitXXStructor(DL, S.Func); 2330 } 2331} 2332 2333void AsmPrinter::emitModuleIdents(Module &M) { 2334 if (!MAI->hasIdentDirective()) 2335 return; 2336 2337 if (const NamedMDNode *NMD = M.getNamedMetadata("llvm.ident")) { 2338 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2339 const MDNode *N = NMD->getOperand(i); 2340 assert(N->getNumOperands() == 1 && 2341 "llvm.ident metadata entry can have only one operand"); 2342 const MDString *S = cast<MDString>(N->getOperand(0)); 2343 OutStreamer->emitIdent(S->getString()); 2344 } 2345 } 2346} 2347 2348void AsmPrinter::emitModuleCommandLines(Module &M) { 2349 MCSection *CommandLine = getObjFileLowering().getSectionForCommandLines(); 2350 if (!CommandLine) 2351 return; 2352 2353 const NamedMDNode *NMD = M.getNamedMetadata("llvm.commandline"); 2354 if (!NMD || !NMD->getNumOperands()) 2355 return; 2356 2357 OutStreamer->PushSection(); 2358 OutStreamer->SwitchSection(CommandLine); 2359 OutStreamer->emitZeros(1); 2360 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 2361 const MDNode *N = NMD->getOperand(i); 2362 assert(N->getNumOperands() == 1 && 2363 "llvm.commandline metadata entry can have only one operand"); 2364 const MDString *S = cast<MDString>(N->getOperand(0)); 2365 OutStreamer->emitBytes(S->getString()); 2366 OutStreamer->emitZeros(1); 2367 } 2368 OutStreamer->PopSection(); 2369} 2370 2371//===--------------------------------------------------------------------===// 2372// Emission and print routines 2373// 2374 2375/// Emit a byte directive and value. 2376/// 2377void AsmPrinter::emitInt8(int Value) const { OutStreamer->emitInt8(Value); } 2378 2379/// Emit a short directive and value. 2380void AsmPrinter::emitInt16(int Value) const { OutStreamer->emitInt16(Value); } 2381 2382/// Emit a long directive and value. 2383void AsmPrinter::emitInt32(int Value) const { OutStreamer->emitInt32(Value); } 2384 2385/// Emit a long long directive and value. 2386void AsmPrinter::emitInt64(uint64_t Value) const { 2387 OutStreamer->emitInt64(Value); 2388} 2389 2390/// Emit something like ".long Hi-Lo" where the size in bytes of the directive 2391/// is specified by Size and Hi/Lo specify the labels. This implicitly uses 2392/// .set if it avoids relocations. 2393void AsmPrinter::emitLabelDifference(const MCSymbol *Hi, const MCSymbol *Lo, 2394 unsigned Size) const { 2395 OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, Size); 2396} 2397 2398/// EmitLabelPlusOffset - Emit something like ".long Label+Offset" 2399/// where the size in bytes of the directive is specified by Size and Label 2400/// specifies the label. This implicitly uses .set if it is available. 2401void AsmPrinter::emitLabelPlusOffset(const MCSymbol *Label, uint64_t Offset, 2402 unsigned Size, 2403 bool IsSectionRelative) const { 2404 if (MAI->needsDwarfSectionOffsetDirective() && IsSectionRelative) { 2405 OutStreamer->EmitCOFFSecRel32(Label, Offset); 2406 if (Size > 4) 2407 OutStreamer->emitZeros(Size - 4); 2408 return; 2409 } 2410 2411 // Emit Label+Offset (or just Label if Offset is zero) 2412 const MCExpr *Expr = MCSymbolRefExpr::create(Label, OutContext); 2413 if (Offset) 2414 Expr = MCBinaryExpr::createAdd( 2415 Expr, MCConstantExpr::create(Offset, OutContext), OutContext); 2416 2417 OutStreamer->emitValue(Expr, Size); 2418} 2419 2420//===----------------------------------------------------------------------===// 2421 2422// EmitAlignment - Emit an alignment directive to the specified power of 2423// two boundary. If a global value is specified, and if that global has 2424// an explicit alignment requested, it will override the alignment request 2425// if required for correctness. 2426void AsmPrinter::emitAlignment(Align Alignment, const GlobalObject *GV) const { 2427 if (GV) 2428 Alignment = getGVAlignment(GV, GV->getParent()->getDataLayout(), Alignment); 2429 2430 if (Alignment == Align(1)) 2431 return; // 1-byte aligned: no need to emit alignment. 2432 2433 if (getCurrentSection()->getKind().isText()) 2434 OutStreamer->emitCodeAlignment(Alignment.value()); 2435 else 2436 OutStreamer->emitValueToAlignment(Alignment.value()); 2437} 2438 2439//===----------------------------------------------------------------------===// 2440// Constant emission. 2441//===----------------------------------------------------------------------===// 2442 2443const MCExpr *AsmPrinter::lowerConstant(const Constant *CV) { 2444 MCContext &Ctx = OutContext; 2445 2446 if (CV->isNullValue() || isa<UndefValue>(CV)) 2447 return MCConstantExpr::create(0, Ctx); 2448 2449 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) 2450 return MCConstantExpr::create(CI->getZExtValue(), Ctx); 2451 2452 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) 2453 return MCSymbolRefExpr::create(getSymbol(GV), Ctx); 2454 2455 if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV)) 2456 return MCSymbolRefExpr::create(GetBlockAddressSymbol(BA), Ctx); 2457 2458 if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) 2459 return getObjFileLowering().lowerDSOLocalEquivalent(Equiv, TM); 2460 2461 const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV); 2462 if (!CE) { 2463 llvm_unreachable("Unknown constant value to lower!"); 2464 } 2465 2466 switch (CE->getOpcode()) { 2467 case Instruction::AddrSpaceCast: { 2468 const Constant *Op = CE->getOperand(0); 2469 unsigned DstAS = CE->getType()->getPointerAddressSpace(); 2470 unsigned SrcAS = Op->getType()->getPointerAddressSpace(); 2471 if (TM.isNoopAddrSpaceCast(SrcAS, DstAS)) 2472 return lowerConstant(Op); 2473 2474 // Fallthrough to error. 2475 LLVM_FALLTHROUGH; 2476 } 2477 default: { 2478 // If the code isn't optimized, there may be outstanding folding 2479 // opportunities. Attempt to fold the expression using DataLayout as a 2480 // last resort before giving up. 2481 Constant *C = ConstantFoldConstant(CE, getDataLayout()); 2482 if (C != CE) 2483 return lowerConstant(C); 2484 2485 // Otherwise report the problem to the user. 2486 std::string S; 2487 raw_string_ostream OS(S); 2488 OS << "Unsupported expression in static initializer: "; 2489 CE->printAsOperand(OS, /*PrintType=*/false, 2490 !MF ? nullptr : MF->getFunction().getParent()); 2491 report_fatal_error(OS.str()); 2492 } 2493 case Instruction::GetElementPtr: { 2494 // Generate a symbolic expression for the byte address 2495 APInt OffsetAI(getDataLayout().getPointerTypeSizeInBits(CE->getType()), 0); 2496 cast<GEPOperator>(CE)->accumulateConstantOffset(getDataLayout(), OffsetAI); 2497 2498 const MCExpr *Base = lowerConstant(CE->getOperand(0)); 2499 if (!OffsetAI) 2500 return Base; 2501 2502 int64_t Offset = OffsetAI.getSExtValue(); 2503 return MCBinaryExpr::createAdd(Base, MCConstantExpr::create(Offset, Ctx), 2504 Ctx); 2505 } 2506 2507 case Instruction::Trunc: 2508 // We emit the value and depend on the assembler to truncate the generated 2509 // expression properly. This is important for differences between 2510 // blockaddress labels. Since the two labels are in the same function, it 2511 // is reasonable to treat their delta as a 32-bit value. 2512 LLVM_FALLTHROUGH; 2513 case Instruction::BitCast: 2514 return lowerConstant(CE->getOperand(0)); 2515 2516 case Instruction::IntToPtr: { 2517 const DataLayout &DL = getDataLayout(); 2518 2519 // Handle casts to pointers by changing them into casts to the appropriate 2520 // integer type. This promotes constant folding and simplifies this code. 2521 Constant *Op = CE->getOperand(0); 2522 Op = ConstantExpr::getIntegerCast(Op, DL.getIntPtrType(CV->getType()), 2523 false/*ZExt*/); 2524 return lowerConstant(Op); 2525 } 2526 2527 case Instruction::PtrToInt: { 2528 const DataLayout &DL = getDataLayout(); 2529 2530 // Support only foldable casts to/from pointers that can be eliminated by 2531 // changing the pointer to the appropriately sized integer type. 2532 Constant *Op = CE->getOperand(0); 2533 Type *Ty = CE->getType(); 2534 2535 const MCExpr *OpExpr = lowerConstant(Op); 2536 2537 // We can emit the pointer value into this slot if the slot is an 2538 // integer slot equal to the size of the pointer. 2539 // 2540 // If the pointer is larger than the resultant integer, then 2541 // as with Trunc just depend on the assembler to truncate it. 2542 if (DL.getTypeAllocSize(Ty).getFixedSize() <= 2543 DL.getTypeAllocSize(Op->getType()).getFixedSize()) 2544 return OpExpr; 2545 2546 // Otherwise the pointer is smaller than the resultant integer, mask off 2547 // the high bits so we are sure to get a proper truncation if the input is 2548 // a constant expr. 2549 unsigned InBits = DL.getTypeAllocSizeInBits(Op->getType()); 2550 const MCExpr *MaskExpr = MCConstantExpr::create(~0ULL >> (64-InBits), Ctx); 2551 return MCBinaryExpr::createAnd(OpExpr, MaskExpr, Ctx); 2552 } 2553 2554 case Instruction::Sub: { 2555 GlobalValue *LHSGV; 2556 APInt LHSOffset; 2557 DSOLocalEquivalent *DSOEquiv; 2558 if (IsConstantOffsetFromGlobal(CE->getOperand(0), LHSGV, LHSOffset, 2559 getDataLayout(), &DSOEquiv)) { 2560 GlobalValue *RHSGV; 2561 APInt RHSOffset; 2562 if (IsConstantOffsetFromGlobal(CE->getOperand(1), RHSGV, RHSOffset, 2563 getDataLayout())) { 2564 const MCExpr *RelocExpr = 2565 getObjFileLowering().lowerRelativeReference(LHSGV, RHSGV, TM); 2566 if (!RelocExpr) { 2567 const MCExpr *LHSExpr = 2568 MCSymbolRefExpr::create(getSymbol(LHSGV), Ctx); 2569 if (DSOEquiv && 2570 getObjFileLowering().supportDSOLocalEquivalentLowering()) 2571 LHSExpr = 2572 getObjFileLowering().lowerDSOLocalEquivalent(DSOEquiv, TM); 2573 RelocExpr = MCBinaryExpr::createSub( 2574 LHSExpr, MCSymbolRefExpr::create(getSymbol(RHSGV), Ctx), Ctx); 2575 } 2576 int64_t Addend = (LHSOffset - RHSOffset).getSExtValue(); 2577 if (Addend != 0) 2578 RelocExpr = MCBinaryExpr::createAdd( 2579 RelocExpr, MCConstantExpr::create(Addend, Ctx), Ctx); 2580 return RelocExpr; 2581 } 2582 } 2583 } 2584 // else fallthrough 2585 LLVM_FALLTHROUGH; 2586 2587 // The MC library also has a right-shift operator, but it isn't consistently 2588 // signed or unsigned between different targets. 2589 case Instruction::Add: 2590 case Instruction::Mul: 2591 case Instruction::SDiv: 2592 case Instruction::SRem: 2593 case Instruction::Shl: 2594 case Instruction::And: 2595 case Instruction::Or: 2596 case Instruction::Xor: { 2597 const MCExpr *LHS = lowerConstant(CE->getOperand(0)); 2598 const MCExpr *RHS = lowerConstant(CE->getOperand(1)); 2599 switch (CE->getOpcode()) { 2600 default: llvm_unreachable("Unknown binary operator constant cast expr"); 2601 case Instruction::Add: return MCBinaryExpr::createAdd(LHS, RHS, Ctx); 2602 case Instruction::Sub: return MCBinaryExpr::createSub(LHS, RHS, Ctx); 2603 case Instruction::Mul: return MCBinaryExpr::createMul(LHS, RHS, Ctx); 2604 case Instruction::SDiv: return MCBinaryExpr::createDiv(LHS, RHS, Ctx); 2605 case Instruction::SRem: return MCBinaryExpr::createMod(LHS, RHS, Ctx); 2606 case Instruction::Shl: return MCBinaryExpr::createShl(LHS, RHS, Ctx); 2607 case Instruction::And: return MCBinaryExpr::createAnd(LHS, RHS, Ctx); 2608 case Instruction::Or: return MCBinaryExpr::createOr (LHS, RHS, Ctx); 2609 case Instruction::Xor: return MCBinaryExpr::createXor(LHS, RHS, Ctx); 2610 } 2611 } 2612 } 2613} 2614 2615static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *C, 2616 AsmPrinter &AP, 2617 const Constant *BaseCV = nullptr, 2618 uint64_t Offset = 0); 2619 2620static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP); 2621static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP); 2622 2623/// isRepeatedByteSequence - Determine whether the given value is 2624/// composed of a repeated sequence of identical bytes and return the 2625/// byte value. If it is not a repeated sequence, return -1. 2626static int isRepeatedByteSequence(const ConstantDataSequential *V) { 2627 StringRef Data = V->getRawDataValues(); 2628 assert(!Data.empty() && "Empty aggregates should be CAZ node"); 2629 char C = Data[0]; 2630 for (unsigned i = 1, e = Data.size(); i != e; ++i) 2631 if (Data[i] != C) return -1; 2632 return static_cast<uint8_t>(C); // Ensure 255 is not returned as -1. 2633} 2634 2635/// isRepeatedByteSequence - Determine whether the given value is 2636/// composed of a repeated sequence of identical bytes and return the 2637/// byte value. If it is not a repeated sequence, return -1. 2638static int isRepeatedByteSequence(const Value *V, const DataLayout &DL) { 2639 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 2640 uint64_t Size = DL.getTypeAllocSizeInBits(V->getType()); 2641 assert(Size % 8 == 0); 2642 2643 // Extend the element to take zero padding into account. 2644 APInt Value = CI->getValue().zextOrSelf(Size); 2645 if (!Value.isSplat(8)) 2646 return -1; 2647 2648 return Value.zextOrTrunc(8).getZExtValue(); 2649 } 2650 if (const ConstantArray *CA = dyn_cast<ConstantArray>(V)) { 2651 // Make sure all array elements are sequences of the same repeated 2652 // byte. 2653 assert(CA->getNumOperands() != 0 && "Should be a CAZ"); 2654 Constant *Op0 = CA->getOperand(0); 2655 int Byte = isRepeatedByteSequence(Op0, DL); 2656 if (Byte == -1) 2657 return -1; 2658 2659 // All array elements must be equal. 2660 for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) 2661 if (CA->getOperand(i) != Op0) 2662 return -1; 2663 return Byte; 2664 } 2665 2666 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V)) 2667 return isRepeatedByteSequence(CDS); 2668 2669 return -1; 2670} 2671 2672static void emitGlobalConstantDataSequential(const DataLayout &DL, 2673 const ConstantDataSequential *CDS, 2674 AsmPrinter &AP) { 2675 // See if we can aggregate this into a .fill, if so, emit it as such. 2676 int Value = isRepeatedByteSequence(CDS, DL); 2677 if (Value != -1) { 2678 uint64_t Bytes = DL.getTypeAllocSize(CDS->getType()); 2679 // Don't emit a 1-byte object as a .fill. 2680 if (Bytes > 1) 2681 return AP.OutStreamer->emitFill(Bytes, Value); 2682 } 2683 2684 // If this can be emitted with .ascii/.asciz, emit it as such. 2685 if (CDS->isString()) 2686 return AP.OutStreamer->emitBytes(CDS->getAsString()); 2687 2688 // Otherwise, emit the values in successive locations. 2689 unsigned ElementByteSize = CDS->getElementByteSize(); 2690 if (isa<IntegerType>(CDS->getElementType())) { 2691 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) { 2692 if (AP.isVerbose()) 2693 AP.OutStreamer->GetCommentOS() << format("0x%" PRIx64 "\n", 2694 CDS->getElementAsInteger(i)); 2695 AP.OutStreamer->emitIntValue(CDS->getElementAsInteger(i), 2696 ElementByteSize); 2697 } 2698 } else { 2699 Type *ET = CDS->getElementType(); 2700 for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) 2701 emitGlobalConstantFP(CDS->getElementAsAPFloat(I), ET, AP); 2702 } 2703 2704 unsigned Size = DL.getTypeAllocSize(CDS->getType()); 2705 unsigned EmittedSize = 2706 DL.getTypeAllocSize(CDS->getElementType()) * CDS->getNumElements(); 2707 assert(EmittedSize <= Size && "Size cannot be less than EmittedSize!"); 2708 if (unsigned Padding = Size - EmittedSize) 2709 AP.OutStreamer->emitZeros(Padding); 2710} 2711 2712static void emitGlobalConstantArray(const DataLayout &DL, 2713 const ConstantArray *CA, AsmPrinter &AP, 2714 const Constant *BaseCV, uint64_t Offset) { 2715 // See if we can aggregate some values. Make sure it can be 2716 // represented as a series of bytes of the constant value. 2717 int Value = isRepeatedByteSequence(CA, DL); 2718 2719 if (Value != -1) { 2720 uint64_t Bytes = DL.getTypeAllocSize(CA->getType()); 2721 AP.OutStreamer->emitFill(Bytes, Value); 2722 } 2723 else { 2724 for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) { 2725 emitGlobalConstantImpl(DL, CA->getOperand(i), AP, BaseCV, Offset); 2726 Offset += DL.getTypeAllocSize(CA->getOperand(i)->getType()); 2727 } 2728 } 2729} 2730 2731static void emitGlobalConstantVector(const DataLayout &DL, 2732 const ConstantVector *CV, AsmPrinter &AP) { 2733 for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) 2734 emitGlobalConstantImpl(DL, CV->getOperand(i), AP); 2735 2736 unsigned Size = DL.getTypeAllocSize(CV->getType()); 2737 unsigned EmittedSize = DL.getTypeAllocSize(CV->getType()->getElementType()) * 2738 CV->getType()->getNumElements(); 2739 if (unsigned Padding = Size - EmittedSize) 2740 AP.OutStreamer->emitZeros(Padding); 2741} 2742 2743static void emitGlobalConstantStruct(const DataLayout &DL, 2744 const ConstantStruct *CS, AsmPrinter &AP, 2745 const Constant *BaseCV, uint64_t Offset) { 2746 // Print the fields in successive locations. Pad to align if needed! 2747 unsigned Size = DL.getTypeAllocSize(CS->getType()); 2748 const StructLayout *Layout = DL.getStructLayout(CS->getType()); 2749 uint64_t SizeSoFar = 0; 2750 for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) { 2751 const Constant *Field = CS->getOperand(i); 2752 2753 // Print the actual field value. 2754 emitGlobalConstantImpl(DL, Field, AP, BaseCV, Offset + SizeSoFar); 2755 2756 // Check if padding is needed and insert one or more 0s. 2757 uint64_t FieldSize = DL.getTypeAllocSize(Field->getType()); 2758 uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1)) 2759 - Layout->getElementOffset(i)) - FieldSize; 2760 SizeSoFar += FieldSize + PadSize; 2761 2762 // Insert padding - this may include padding to increase the size of the 2763 // current field up to the ABI size (if the struct is not packed) as well 2764 // as padding to ensure that the next field starts at the right offset. 2765 AP.OutStreamer->emitZeros(PadSize); 2766 } 2767 assert(SizeSoFar == Layout->getSizeInBytes() && 2768 "Layout of constant struct may be incorrect!"); 2769} 2770 2771static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) { 2772 assert(ET && "Unknown float type"); 2773 APInt API = APF.bitcastToAPInt(); 2774 2775 // First print a comment with what we think the original floating-point value 2776 // should have been. 2777 if (AP.isVerbose()) { 2778 SmallString<8> StrVal; 2779 APF.toString(StrVal); 2780 ET->print(AP.OutStreamer->GetCommentOS()); 2781 AP.OutStreamer->GetCommentOS() << ' ' << StrVal << '\n'; 2782 } 2783 2784 // Now iterate through the APInt chunks, emitting them in endian-correct 2785 // order, possibly with a smaller chunk at beginning/end (e.g. for x87 80-bit 2786 // floats). 2787 unsigned NumBytes = API.getBitWidth() / 8; 2788 unsigned TrailingBytes = NumBytes % sizeof(uint64_t); 2789 const uint64_t *p = API.getRawData(); 2790 2791 // PPC's long double has odd notions of endianness compared to how LLVM 2792 // handles it: p[0] goes first for *big* endian on PPC. 2793 if (AP.getDataLayout().isBigEndian() && !ET->isPPC_FP128Ty()) { 2794 int Chunk = API.getNumWords() - 1; 2795 2796 if (TrailingBytes) 2797 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk--], TrailingBytes); 2798 2799 for (; Chunk >= 0; --Chunk) 2800 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t)); 2801 } else { 2802 unsigned Chunk; 2803 for (Chunk = 0; Chunk < NumBytes / sizeof(uint64_t); ++Chunk) 2804 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], sizeof(uint64_t)); 2805 2806 if (TrailingBytes) 2807 AP.OutStreamer->emitIntValueInHexWithPadding(p[Chunk], TrailingBytes); 2808 } 2809 2810 // Emit the tail padding for the long double. 2811 const DataLayout &DL = AP.getDataLayout(); 2812 AP.OutStreamer->emitZeros(DL.getTypeAllocSize(ET) - DL.getTypeStoreSize(ET)); 2813} 2814 2815static void emitGlobalConstantFP(const ConstantFP *CFP, AsmPrinter &AP) { 2816 emitGlobalConstantFP(CFP->getValueAPF(), CFP->getType(), AP); 2817} 2818 2819static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) { 2820 const DataLayout &DL = AP.getDataLayout(); 2821 unsigned BitWidth = CI->getBitWidth(); 2822 2823 // Copy the value as we may massage the layout for constants whose bit width 2824 // is not a multiple of 64-bits. 2825 APInt Realigned(CI->getValue()); 2826 uint64_t ExtraBits = 0; 2827 unsigned ExtraBitsSize = BitWidth & 63; 2828 2829 if (ExtraBitsSize) { 2830 // The bit width of the data is not a multiple of 64-bits. 2831 // The extra bits are expected to be at the end of the chunk of the memory. 2832 // Little endian: 2833 // * Nothing to be done, just record the extra bits to emit. 2834 // Big endian: 2835 // * Record the extra bits to emit. 2836 // * Realign the raw data to emit the chunks of 64-bits. 2837 if (DL.isBigEndian()) { 2838 // Basically the structure of the raw data is a chunk of 64-bits cells: 2839 // 0 1 BitWidth / 64 2840 // [chunk1][chunk2] ... [chunkN]. 2841 // The most significant chunk is chunkN and it should be emitted first. 2842 // However, due to the alignment issue chunkN contains useless bits. 2843 // Realign the chunks so that they contain only useful information: 2844 // ExtraBits 0 1 (BitWidth / 64) - 1 2845 // chu[nk1 chu][nk2 chu] ... [nkN-1 chunkN] 2846 ExtraBitsSize = alignTo(ExtraBitsSize, 8); 2847 ExtraBits = Realigned.getRawData()[0] & 2848 (((uint64_t)-1) >> (64 - ExtraBitsSize)); 2849 Realigned.lshrInPlace(ExtraBitsSize); 2850 } else 2851 ExtraBits = Realigned.getRawData()[BitWidth / 64]; 2852 } 2853 2854 // We don't expect assemblers to support integer data directives 2855 // for more than 64 bits, so we emit the data in at most 64-bit 2856 // quantities at a time. 2857 const uint64_t *RawData = Realigned.getRawData(); 2858 for (unsigned i = 0, e = BitWidth / 64; i != e; ++i) { 2859 uint64_t Val = DL.isBigEndian() ? RawData[e - i - 1] : RawData[i]; 2860 AP.OutStreamer->emitIntValue(Val, 8); 2861 } 2862 2863 if (ExtraBitsSize) { 2864 // Emit the extra bits after the 64-bits chunks. 2865 2866 // Emit a directive that fills the expected size. 2867 uint64_t Size = AP.getDataLayout().getTypeStoreSize(CI->getType()); 2868 Size -= (BitWidth / 64) * 8; 2869 assert(Size && Size * 8 >= ExtraBitsSize && 2870 (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize))) 2871 == ExtraBits && "Directive too small for extra bits."); 2872 AP.OutStreamer->emitIntValue(ExtraBits, Size); 2873 } 2874} 2875 2876/// Transform a not absolute MCExpr containing a reference to a GOT 2877/// equivalent global, by a target specific GOT pc relative access to the 2878/// final symbol. 2879static void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, const MCExpr **ME, 2880 const Constant *BaseCst, 2881 uint64_t Offset) { 2882 // The global @foo below illustrates a global that uses a got equivalent. 2883 // 2884 // @bar = global i32 42 2885 // @gotequiv = private unnamed_addr constant i32* @bar 2886 // @foo = i32 trunc (i64 sub (i64 ptrtoint (i32** @gotequiv to i64), 2887 // i64 ptrtoint (i32* @foo to i64)) 2888 // to i32) 2889 // 2890 // The cstexpr in @foo is converted into the MCExpr `ME`, where we actually 2891 // check whether @foo is suitable to use a GOTPCREL. `ME` is usually in the 2892 // form: 2893 // 2894 // foo = cstexpr, where 2895 // cstexpr := <gotequiv> - "." + <cst> 2896 // cstexpr := <gotequiv> - (<foo> - <offset from @foo base>) + <cst> 2897 // 2898 // After canonicalization by evaluateAsRelocatable `ME` turns into: 2899 // 2900 // cstexpr := <gotequiv> - <foo> + gotpcrelcst, where 2901 // gotpcrelcst := <offset from @foo base> + <cst> 2902 MCValue MV; 2903 if (!(*ME)->evaluateAsRelocatable(MV, nullptr, nullptr) || MV.isAbsolute()) 2904 return; 2905 const MCSymbolRefExpr *SymA = MV.getSymA(); 2906 if (!SymA) 2907 return; 2908 2909 // Check that GOT equivalent symbol is cached. 2910 const MCSymbol *GOTEquivSym = &SymA->getSymbol(); 2911 if (!AP.GlobalGOTEquivs.count(GOTEquivSym)) 2912 return; 2913 2914 const GlobalValue *BaseGV = dyn_cast_or_null<GlobalValue>(BaseCst); 2915 if (!BaseGV) 2916 return; 2917 2918 // Check for a valid base symbol 2919 const MCSymbol *BaseSym = AP.getSymbol(BaseGV); 2920 const MCSymbolRefExpr *SymB = MV.getSymB(); 2921 2922 if (!SymB || BaseSym != &SymB->getSymbol()) 2923 return; 2924 2925 // Make sure to match: 2926 // 2927 // gotpcrelcst := <offset from @foo base> + <cst> 2928 // 2929 // If gotpcrelcst is positive it means that we can safely fold the pc rel 2930 // displacement into the GOTPCREL. We can also can have an extra offset <cst> 2931 // if the target knows how to encode it. 2932 int64_t GOTPCRelCst = Offset + MV.getConstant(); 2933 if (GOTPCRelCst < 0) 2934 return; 2935 if (!AP.getObjFileLowering().supportGOTPCRelWithOffset() && GOTPCRelCst != 0) 2936 return; 2937 2938 // Emit the GOT PC relative to replace the got equivalent global, i.e.: 2939 // 2940 // bar: 2941 // .long 42 2942 // gotequiv: 2943 // .quad bar 2944 // foo: 2945 // .long gotequiv - "." + <cst> 2946 // 2947 // is replaced by the target specific equivalent to: 2948 // 2949 // bar: 2950 // .long 42 2951 // foo: 2952 // .long bar@GOTPCREL+<gotpcrelcst> 2953 AsmPrinter::GOTEquivUsePair Result = AP.GlobalGOTEquivs[GOTEquivSym]; 2954 const GlobalVariable *GV = Result.first; 2955 int NumUses = (int)Result.second; 2956 const GlobalValue *FinalGV = dyn_cast<GlobalValue>(GV->getOperand(0)); 2957 const MCSymbol *FinalSym = AP.getSymbol(FinalGV); 2958 *ME = AP.getObjFileLowering().getIndirectSymViaGOTPCRel( 2959 FinalGV, FinalSym, MV, Offset, AP.MMI, *AP.OutStreamer); 2960 2961 // Update GOT equivalent usage information 2962 --NumUses; 2963 if (NumUses >= 0) 2964 AP.GlobalGOTEquivs[GOTEquivSym] = std::make_pair(GV, NumUses); 2965} 2966 2967static void emitGlobalConstantImpl(const DataLayout &DL, const Constant *CV, 2968 AsmPrinter &AP, const Constant *BaseCV, 2969 uint64_t Offset) { 2970 uint64_t Size = DL.getTypeAllocSize(CV->getType()); 2971 2972 // Globals with sub-elements such as combinations of arrays and structs 2973 // are handled recursively by emitGlobalConstantImpl. Keep track of the 2974 // constant symbol base and the current position with BaseCV and Offset. 2975 if (!BaseCV && CV->hasOneUse()) 2976 BaseCV = dyn_cast<Constant>(CV->user_back()); 2977 2978 if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV)) 2979 return AP.OutStreamer->emitZeros(Size); 2980 2981 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) { 2982 const uint64_t StoreSize = DL.getTypeStoreSize(CV->getType()); 2983 2984 if (StoreSize <= 8) { 2985 if (AP.isVerbose()) 2986 AP.OutStreamer->GetCommentOS() << format("0x%" PRIx64 "\n", 2987 CI->getZExtValue()); 2988 AP.OutStreamer->emitIntValue(CI->getZExtValue(), StoreSize); 2989 } else { 2990 emitGlobalConstantLargeInt(CI, AP); 2991 } 2992 2993 // Emit tail padding if needed 2994 if (Size != StoreSize) 2995 AP.OutStreamer->emitZeros(Size - StoreSize); 2996 2997 return; 2998 } 2999 3000 if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV)) 3001 return emitGlobalConstantFP(CFP, AP); 3002 3003 if (isa<ConstantPointerNull>(CV)) { 3004 AP.OutStreamer->emitIntValue(0, Size); 3005 return; 3006 } 3007 3008 if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV)) 3009 return emitGlobalConstantDataSequential(DL, CDS, AP); 3010 3011 if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) 3012 return emitGlobalConstantArray(DL, CVA, AP, BaseCV, Offset); 3013 3014 if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) 3015 return emitGlobalConstantStruct(DL, CVS, AP, BaseCV, Offset); 3016 3017 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { 3018 // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of 3019 // vectors). 3020 if (CE->getOpcode() == Instruction::BitCast) 3021 return emitGlobalConstantImpl(DL, CE->getOperand(0), AP); 3022 3023 if (Size > 8) { 3024 // If the constant expression's size is greater than 64-bits, then we have 3025 // to emit the value in chunks. Try to constant fold the value and emit it 3026 // that way. 3027 Constant *New = ConstantFoldConstant(CE, DL); 3028 if (New != CE) 3029 return emitGlobalConstantImpl(DL, New, AP); 3030 } 3031 } 3032 3033 if (const ConstantVector *V = dyn_cast<ConstantVector>(CV)) 3034 return emitGlobalConstantVector(DL, V, AP); 3035 3036 // Otherwise, it must be a ConstantExpr. Lower it to an MCExpr, then emit it 3037 // thread the streamer with EmitValue. 3038 const MCExpr *ME = AP.lowerConstant(CV); 3039 3040 // Since lowerConstant already folded and got rid of all IR pointer and 3041 // integer casts, detect GOT equivalent accesses by looking into the MCExpr 3042 // directly. 3043 if (AP.getObjFileLowering().supportIndirectSymViaGOTPCRel()) 3044 handleIndirectSymViaGOTPCRel(AP, &ME, BaseCV, Offset); 3045 3046 AP.OutStreamer->emitValue(ME, Size); 3047} 3048 3049/// EmitGlobalConstant - Print a general LLVM constant to the .s file. 3050void AsmPrinter::emitGlobalConstant(const DataLayout &DL, const Constant *CV) { 3051 uint64_t Size = DL.getTypeAllocSize(CV->getType()); 3052 if (Size) 3053 emitGlobalConstantImpl(DL, CV, *this); 3054 else if (MAI->hasSubsectionsViaSymbols()) { 3055 // If the global has zero size, emit a single byte so that two labels don't 3056 // look like they are at the same location. 3057 OutStreamer->emitIntValue(0, 1); 3058 } 3059} 3060 3061void AsmPrinter::emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) { 3062 // Target doesn't support this yet! 3063 llvm_unreachable("Target does not support EmitMachineConstantPoolValue"); 3064} 3065 3066void AsmPrinter::printOffset(int64_t Offset, raw_ostream &OS) const { 3067 if (Offset > 0) 3068 OS << '+' << Offset; 3069 else if (Offset < 0) 3070 OS << Offset; 3071} 3072 3073void AsmPrinter::emitNops(unsigned N) { 3074 MCInst Nop = MF->getSubtarget().getInstrInfo()->getNop(); 3075 for (; N; --N) 3076 EmitToStreamer(*OutStreamer, Nop); 3077} 3078 3079//===----------------------------------------------------------------------===// 3080// Symbol Lowering Routines. 3081//===----------------------------------------------------------------------===// 3082 3083MCSymbol *AsmPrinter::createTempSymbol(const Twine &Name) const { 3084 return OutContext.createTempSymbol(Name, true); 3085} 3086 3087MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const { 3088 return MMI->getAddrLabelSymbol(BA->getBasicBlock()); 3089} 3090 3091MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const { 3092 return MMI->getAddrLabelSymbol(BB); 3093} 3094 3095/// GetCPISymbol - Return the symbol for the specified constant pool entry. 3096MCSymbol *AsmPrinter::GetCPISymbol(unsigned CPID) const { 3097 if (getSubtargetInfo().getTargetTriple().isWindowsMSVCEnvironment()) { 3098 const MachineConstantPoolEntry &CPE = 3099 MF->getConstantPool()->getConstants()[CPID]; 3100 if (!CPE.isMachineConstantPoolEntry()) { 3101 const DataLayout &DL = MF->getDataLayout(); 3102 SectionKind Kind = CPE.getSectionKind(&DL); 3103 const Constant *C = CPE.Val.ConstVal; 3104 Align Alignment = CPE.Alignment; 3105 if (const MCSectionCOFF *S = dyn_cast<MCSectionCOFF>( 3106 getObjFileLowering().getSectionForConstant(DL, Kind, C, 3107 Alignment))) { 3108 if (MCSymbol *Sym = S->getCOMDATSymbol()) { 3109 if (Sym->isUndefined()) 3110 OutStreamer->emitSymbolAttribute(Sym, MCSA_Global); 3111 return Sym; 3112 } 3113 } 3114 } 3115 } 3116 3117 const DataLayout &DL = getDataLayout(); 3118 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) + 3119 "CPI" + Twine(getFunctionNumber()) + "_" + 3120 Twine(CPID)); 3121} 3122 3123/// GetJTISymbol - Return the symbol for the specified jump table entry. 3124MCSymbol *AsmPrinter::GetJTISymbol(unsigned JTID, bool isLinkerPrivate) const { 3125 return MF->getJTISymbol(JTID, OutContext, isLinkerPrivate); 3126} 3127 3128/// GetJTSetSymbol - Return the symbol for the specified jump table .set 3129/// FIXME: privatize to AsmPrinter. 3130MCSymbol *AsmPrinter::GetJTSetSymbol(unsigned UID, unsigned MBBID) const { 3131 const DataLayout &DL = getDataLayout(); 3132 return OutContext.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) + 3133 Twine(getFunctionNumber()) + "_" + 3134 Twine(UID) + "_set_" + Twine(MBBID)); 3135} 3136 3137MCSymbol *AsmPrinter::getSymbolWithGlobalValueBase(const GlobalValue *GV, 3138 StringRef Suffix) const { 3139 return getObjFileLowering().getSymbolWithGlobalValueBase(GV, Suffix, TM); 3140} 3141 3142/// Return the MCSymbol for the specified ExternalSymbol. 3143MCSymbol *AsmPrinter::GetExternalSymbolSymbol(StringRef Sym) const { 3144 SmallString<60> NameStr; 3145 Mangler::getNameWithPrefix(NameStr, Sym, getDataLayout()); 3146 return OutContext.getOrCreateSymbol(NameStr); 3147} 3148 3149/// PrintParentLoopComment - Print comments about parent loops of this one. 3150static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop, 3151 unsigned FunctionNumber) { 3152 if (!Loop) return; 3153 PrintParentLoopComment(OS, Loop->getParentLoop(), FunctionNumber); 3154 OS.indent(Loop->getLoopDepth()*2) 3155 << "Parent Loop BB" << FunctionNumber << "_" 3156 << Loop->getHeader()->getNumber() 3157 << " Depth=" << Loop->getLoopDepth() << '\n'; 3158} 3159 3160/// PrintChildLoopComment - Print comments about child loops within 3161/// the loop for this basic block, with nesting. 3162static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop, 3163 unsigned FunctionNumber) { 3164 // Add child loop information 3165 for (const MachineLoop *CL : *Loop) { 3166 OS.indent(CL->getLoopDepth()*2) 3167 << "Child Loop BB" << FunctionNumber << "_" 3168 << CL->getHeader()->getNumber() << " Depth " << CL->getLoopDepth() 3169 << '\n'; 3170 PrintChildLoopComment(OS, CL, FunctionNumber); 3171 } 3172} 3173 3174/// emitBasicBlockLoopComments - Pretty-print comments for basic blocks. 3175static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB, 3176 const MachineLoopInfo *LI, 3177 const AsmPrinter &AP) { 3178 // Add loop depth information 3179 const MachineLoop *Loop = LI->getLoopFor(&MBB); 3180 if (!Loop) return; 3181 3182 MachineBasicBlock *Header = Loop->getHeader(); 3183 assert(Header && "No header for loop"); 3184 3185 // If this block is not a loop header, just print out what is the loop header 3186 // and return. 3187 if (Header != &MBB) { 3188 AP.OutStreamer->AddComment(" in Loop: Header=BB" + 3189 Twine(AP.getFunctionNumber())+"_" + 3190 Twine(Loop->getHeader()->getNumber())+ 3191 " Depth="+Twine(Loop->getLoopDepth())); 3192 return; 3193 } 3194 3195 // Otherwise, it is a loop header. Print out information about child and 3196 // parent loops. 3197 raw_ostream &OS = AP.OutStreamer->GetCommentOS(); 3198 3199 PrintParentLoopComment(OS, Loop->getParentLoop(), AP.getFunctionNumber()); 3200 3201 OS << "=>"; 3202 OS.indent(Loop->getLoopDepth()*2-2); 3203 3204 OS << "This "; 3205 if (Loop->isInnermost()) 3206 OS << "Inner "; 3207 OS << "Loop Header: Depth=" + Twine(Loop->getLoopDepth()) << '\n'; 3208 3209 PrintChildLoopComment(OS, Loop, AP.getFunctionNumber()); 3210} 3211 3212/// emitBasicBlockStart - This method prints the label for the specified 3213/// MachineBasicBlock, an alignment (if present) and a comment describing 3214/// it if appropriate. 3215void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { 3216 // End the previous funclet and start a new one. 3217 if (MBB.isEHFuncletEntry()) { 3218 for (const HandlerInfo &HI : Handlers) { 3219 HI.Handler->endFunclet(); 3220 HI.Handler->beginFunclet(MBB); 3221 } 3222 } 3223 3224 // Emit an alignment directive for this block, if needed. 3225 const Align Alignment = MBB.getAlignment(); 3226 if (Alignment != Align(1)) 3227 emitAlignment(Alignment); 3228 3229 // Switch to a new section if this basic block must begin a section. The 3230 // entry block is always placed in the function section and is handled 3231 // separately. 3232 if (MBB.isBeginSection() && !MBB.isEntryBlock()) { 3233 OutStreamer->SwitchSection( 3234 getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(), 3235 MBB, TM)); 3236 CurrentSectionBeginSym = MBB.getSymbol(); 3237 } 3238 3239 // If the block has its address taken, emit any labels that were used to 3240 // reference the block. It is possible that there is more than one label 3241 // here, because multiple LLVM BB's may have been RAUW'd to this block after 3242 // the references were generated. 3243 if (MBB.hasAddressTaken()) { 3244 const BasicBlock *BB = MBB.getBasicBlock(); 3245 if (isVerbose()) 3246 OutStreamer->AddComment("Block address taken"); 3247 3248 // MBBs can have their address taken as part of CodeGen without having 3249 // their corresponding BB's address taken in IR 3250 if (BB->hasAddressTaken()) 3251 for (MCSymbol *Sym : MMI->getAddrLabelSymbolToEmit(BB)) 3252 OutStreamer->emitLabel(Sym); 3253 } 3254 3255 // Print some verbose block comments. 3256 if (isVerbose()) { 3257 if (const BasicBlock *BB = MBB.getBasicBlock()) { 3258 if (BB->hasName()) { 3259 BB->printAsOperand(OutStreamer->GetCommentOS(), 3260 /*PrintType=*/false, BB->getModule()); 3261 OutStreamer->GetCommentOS() << '\n'; 3262 } 3263 } 3264 3265 assert(MLI != nullptr && "MachineLoopInfo should has been computed"); 3266 emitBasicBlockLoopComments(MBB, MLI, *this); 3267 } 3268 3269 // Print the main label for the block. 3270 if (shouldEmitLabelForBasicBlock(MBB)) { 3271 if (isVerbose() && MBB.hasLabelMustBeEmitted()) 3272 OutStreamer->AddComment("Label of block must be emitted"); 3273 OutStreamer->emitLabel(MBB.getSymbol()); 3274 } else { 3275 if (isVerbose()) { 3276 // NOTE: Want this comment at start of line, don't emit with AddComment. 3277 OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":", 3278 false); 3279 } 3280 } 3281 3282 if (MBB.isEHCatchretTarget() && 3283 MAI->getExceptionHandlingType() == ExceptionHandling::WinEH) { 3284 OutStreamer->emitLabel(MBB.getEHCatchretSymbol()); 3285 } 3286 3287 // With BB sections, each basic block must handle CFI information on its own 3288 // if it begins a section (Entry block is handled separately by 3289 // AsmPrinterHandler::beginFunction). 3290 if (MBB.isBeginSection() && !MBB.isEntryBlock()) 3291 for (const HandlerInfo &HI : Handlers) 3292 HI.Handler->beginBasicBlock(MBB); 3293} 3294 3295void AsmPrinter::emitBasicBlockEnd(const MachineBasicBlock &MBB) { 3296 // Check if CFI information needs to be updated for this MBB with basic block 3297 // sections. 3298 if (MBB.isEndSection()) 3299 for (const HandlerInfo &HI : Handlers) 3300 HI.Handler->endBasicBlock(MBB); 3301} 3302 3303void AsmPrinter::emitVisibility(MCSymbol *Sym, unsigned Visibility, 3304 bool IsDefinition) const { 3305 MCSymbolAttr Attr = MCSA_Invalid; 3306 3307 switch (Visibility) { 3308 default: break; 3309 case GlobalValue::HiddenVisibility: 3310 if (IsDefinition) 3311 Attr = MAI->getHiddenVisibilityAttr(); 3312 else 3313 Attr = MAI->getHiddenDeclarationVisibilityAttr(); 3314 break; 3315 case GlobalValue::ProtectedVisibility: 3316 Attr = MAI->getProtectedVisibilityAttr(); 3317 break; 3318 } 3319 3320 if (Attr != MCSA_Invalid) 3321 OutStreamer->emitSymbolAttribute(Sym, Attr); 3322} 3323 3324bool AsmPrinter::shouldEmitLabelForBasicBlock( 3325 const MachineBasicBlock &MBB) const { 3326 // With `-fbasic-block-sections=`, a label is needed for every non-entry block 3327 // in the labels mode (option `=labels`) and every section beginning in the 3328 // sections mode (`=all` and `=list=`). 3329 if ((MF->hasBBLabels() || MBB.isBeginSection()) && !MBB.isEntryBlock()) 3330 return true; 3331 // A label is needed for any block with at least one predecessor (when that 3332 // predecessor is not the fallthrough predecessor, or if it is an EH funclet 3333 // entry, or if a label is forced). 3334 return !MBB.pred_empty() && 3335 (!isBlockOnlyReachableByFallthrough(&MBB) || MBB.isEHFuncletEntry() || 3336 MBB.hasLabelMustBeEmitted()); 3337} 3338 3339/// isBlockOnlyReachableByFallthough - Return true if the basic block has 3340/// exactly one predecessor and the control transfer mechanism between 3341/// the predecessor and this block is a fall-through. 3342bool AsmPrinter:: 3343isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const { 3344 // If this is a landing pad, it isn't a fall through. If it has no preds, 3345 // then nothing falls through to it. 3346 if (MBB->isEHPad() || MBB->pred_empty()) 3347 return false; 3348 3349 // If there isn't exactly one predecessor, it can't be a fall through. 3350 if (MBB->pred_size() > 1) 3351 return false; 3352 3353 // The predecessor has to be immediately before this block. 3354 MachineBasicBlock *Pred = *MBB->pred_begin(); 3355 if (!Pred->isLayoutSuccessor(MBB)) 3356 return false; 3357 3358 // If the block is completely empty, then it definitely does fall through. 3359 if (Pred->empty()) 3360 return true; 3361 3362 // Check the terminators in the previous blocks 3363 for (const auto &MI : Pred->terminators()) { 3364 // If it is not a simple branch, we are in a table somewhere. 3365 if (!MI.isBranch() || MI.isIndirectBranch()) 3366 return false; 3367 3368 // If we are the operands of one of the branches, this is not a fall 3369 // through. Note that targets with delay slots will usually bundle 3370 // terminators with the delay slot instruction. 3371 for (ConstMIBundleOperands OP(MI); OP.isValid(); ++OP) { 3372 if (OP->isJTI()) 3373 return false; 3374 if (OP->isMBB() && OP->getMBB() == MBB) 3375 return false; 3376 } 3377 } 3378 3379 return true; 3380} 3381 3382GCMetadataPrinter *AsmPrinter::GetOrCreateGCPrinter(GCStrategy &S) { 3383 if (!S.usesMetadata()) 3384 return nullptr; 3385 3386 gcp_map_type &GCMap = getGCMap(GCMetadataPrinters); 3387 gcp_map_type::iterator GCPI = GCMap.find(&S); 3388 if (GCPI != GCMap.end()) 3389 return GCPI->second.get(); 3390 3391 auto Name = S.getName(); 3392 3393 for (const GCMetadataPrinterRegistry::entry &GCMetaPrinter : 3394 GCMetadataPrinterRegistry::entries()) 3395 if (Name == GCMetaPrinter.getName()) { 3396 std::unique_ptr<GCMetadataPrinter> GMP = GCMetaPrinter.instantiate(); 3397 GMP->S = &S; 3398 auto IterBool = GCMap.insert(std::make_pair(&S, std::move(GMP))); 3399 return IterBool.first->second.get(); 3400 } 3401 3402 report_fatal_error("no GCMetadataPrinter registered for GC: " + Twine(Name)); 3403} 3404 3405void AsmPrinter::emitStackMaps(StackMaps &SM) { 3406 GCModuleInfo *MI = getAnalysisIfAvailable<GCModuleInfo>(); 3407 assert(MI && "AsmPrinter didn't require GCModuleInfo?"); 3408 bool NeedsDefault = false; 3409 if (MI->begin() == MI->end()) 3410 // No GC strategy, use the default format. 3411 NeedsDefault = true; 3412 else 3413 for (auto &I : *MI) { 3414 if (GCMetadataPrinter *MP = GetOrCreateGCPrinter(*I)) 3415 if (MP->emitStackMaps(SM, *this)) 3416 continue; 3417 // The strategy doesn't have printer or doesn't emit custom stack maps. 3418 // Use the default format. 3419 NeedsDefault = true; 3420 } 3421 3422 if (NeedsDefault) 3423 SM.serializeToStackMapSection(); 3424} 3425 3426/// Pin vtable to this file. 3427AsmPrinterHandler::~AsmPrinterHandler() = default; 3428 3429void AsmPrinterHandler::markFunctionEnd() {} 3430 3431// In the binary's "xray_instr_map" section, an array of these function entries 3432// describes each instrumentation point. When XRay patches your code, the index 3433// into this table will be given to your handler as a patch point identifier. 3434void AsmPrinter::XRayFunctionEntry::emit(int Bytes, MCStreamer *Out) const { 3435 auto Kind8 = static_cast<uint8_t>(Kind); 3436 Out->emitBinaryData(StringRef(reinterpret_cast<const char *>(&Kind8), 1)); 3437 Out->emitBinaryData( 3438 StringRef(reinterpret_cast<const char *>(&AlwaysInstrument), 1)); 3439 Out->emitBinaryData(StringRef(reinterpret_cast<const char *>(&Version), 1)); 3440 auto Padding = (4 * Bytes) - ((2 * Bytes) + 3); 3441 assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size"); 3442 Out->emitZeros(Padding); 3443} 3444 3445void AsmPrinter::emitXRayTable() { 3446 if (Sleds.empty()) 3447 return; 3448 3449 auto PrevSection = OutStreamer->getCurrentSectionOnly(); 3450 const Function &F = MF->getFunction(); 3451 MCSection *InstMap = nullptr; 3452 MCSection *FnSledIndex = nullptr; 3453 const Triple &TT = TM.getTargetTriple(); 3454 // Use PC-relative addresses on all targets. 3455 if (TT.isOSBinFormatELF()) { 3456 auto LinkedToSym = cast<MCSymbolELF>(CurrentFnSym); 3457 auto Flags = ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER; 3458 StringRef GroupName; 3459 if (F.hasComdat()) { 3460 Flags |= ELF::SHF_GROUP; 3461 GroupName = F.getComdat()->getName(); 3462 } 3463 InstMap = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, 3464 Flags, 0, GroupName, F.hasComdat(), 3465 MCSection::NonUniqueID, LinkedToSym); 3466 3467 if (!TM.Options.XRayOmitFunctionIndex) 3468 FnSledIndex = OutContext.getELFSection( 3469 "xray_fn_idx", ELF::SHT_PROGBITS, Flags | ELF::SHF_WRITE, 0, 3470 GroupName, F.hasComdat(), MCSection::NonUniqueID, LinkedToSym); 3471 } else if (MF->getSubtarget().getTargetTriple().isOSBinFormatMachO()) { 3472 InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map", 0, 3473 SectionKind::getReadOnlyWithRel()); 3474 if (!TM.Options.XRayOmitFunctionIndex) 3475 FnSledIndex = OutContext.getMachOSection( 3476 "__DATA", "xray_fn_idx", 0, SectionKind::getReadOnlyWithRel()); 3477 } else { 3478 llvm_unreachable("Unsupported target"); 3479 } 3480 3481 auto WordSizeBytes = MAI->getCodePointerSize(); 3482 3483 // Now we switch to the instrumentation map section. Because this is done 3484 // per-function, we are able to create an index entry that will represent the 3485 // range of sleds associated with a function. 3486 auto &Ctx = OutContext; 3487 MCSymbol *SledsStart = OutContext.createTempSymbol("xray_sleds_start", true); 3488 OutStreamer->SwitchSection(InstMap); 3489 OutStreamer->emitLabel(SledsStart); 3490 for (const auto &Sled : Sleds) { 3491 MCSymbol *Dot = Ctx.createTempSymbol(); 3492 OutStreamer->emitLabel(Dot); 3493 OutStreamer->emitValueImpl( 3494 MCBinaryExpr::createSub(MCSymbolRefExpr::create(Sled.Sled, Ctx), 3495 MCSymbolRefExpr::create(Dot, Ctx), Ctx), 3496 WordSizeBytes); 3497 OutStreamer->emitValueImpl( 3498 MCBinaryExpr::createSub( 3499 MCSymbolRefExpr::create(CurrentFnBegin, Ctx), 3500 MCBinaryExpr::createAdd(MCSymbolRefExpr::create(Dot, Ctx), 3501 MCConstantExpr::create(WordSizeBytes, Ctx), 3502 Ctx), 3503 Ctx), 3504 WordSizeBytes); 3505 Sled.emit(WordSizeBytes, OutStreamer.get()); 3506 } 3507 MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true); 3508 OutStreamer->emitLabel(SledsEnd); 3509 3510 // We then emit a single entry in the index per function. We use the symbols 3511 // that bound the instrumentation map as the range for a specific function. 3512 // Each entry here will be 2 * word size aligned, as we're writing down two 3513 // pointers. This should work for both 32-bit and 64-bit platforms. 3514 if (FnSledIndex) { 3515 OutStreamer->SwitchSection(FnSledIndex); 3516 OutStreamer->emitCodeAlignment(2 * WordSizeBytes); 3517 OutStreamer->emitSymbolValue(SledsStart, WordSizeBytes, false); 3518 OutStreamer->emitSymbolValue(SledsEnd, WordSizeBytes, false); 3519 OutStreamer->SwitchSection(PrevSection); 3520 } 3521 Sleds.clear(); 3522} 3523 3524void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI, 3525 SledKind Kind, uint8_t Version) { 3526 const Function &F = MI.getMF()->getFunction(); 3527 auto Attr = F.getFnAttribute("function-instrument"); 3528 bool LogArgs = F.hasFnAttribute("xray-log-args"); 3529 bool AlwaysInstrument = 3530 Attr.isStringAttribute() && Attr.getValueAsString() == "xray-always"; 3531 if (Kind == SledKind::FUNCTION_ENTER && LogArgs) 3532 Kind = SledKind::LOG_ARGS_ENTER; 3533 Sleds.emplace_back(XRayFunctionEntry{Sled, CurrentFnSym, Kind, 3534 AlwaysInstrument, &F, Version}); 3535} 3536 3537void AsmPrinter::emitPatchableFunctionEntries() { 3538 const Function &F = MF->getFunction(); 3539 unsigned PatchableFunctionPrefix = 0, PatchableFunctionEntry = 0; 3540 (void)F.getFnAttribute("patchable-function-prefix") 3541 .getValueAsString() 3542 .getAsInteger(10, PatchableFunctionPrefix); 3543 (void)F.getFnAttribute("patchable-function-entry") 3544 .getValueAsString() 3545 .getAsInteger(10, PatchableFunctionEntry); 3546 if (!PatchableFunctionPrefix && !PatchableFunctionEntry) 3547 return; 3548 const unsigned PointerSize = getPointerSize(); 3549 if (TM.getTargetTriple().isOSBinFormatELF()) { 3550 auto Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC; 3551 const MCSymbolELF *LinkedToSym = nullptr; 3552 StringRef GroupName; 3553 3554 // GNU as < 2.35 did not support section flag 'o'. GNU ld < 2.36 did not 3555 // support mixed SHF_LINK_ORDER and non-SHF_LINK_ORDER sections. 3556 if (MAI->useIntegratedAssembler() || MAI->binutilsIsAtLeast(2, 36)) { 3557 Flags |= ELF::SHF_LINK_ORDER; 3558 if (F.hasComdat()) { 3559 Flags |= ELF::SHF_GROUP; 3560 GroupName = F.getComdat()->getName(); 3561 } 3562 LinkedToSym = cast<MCSymbolELF>(CurrentFnSym); 3563 } 3564 OutStreamer->SwitchSection(OutContext.getELFSection( 3565 "__patchable_function_entries", ELF::SHT_PROGBITS, Flags, 0, GroupName, 3566 F.hasComdat(), MCSection::NonUniqueID, LinkedToSym)); 3567 emitAlignment(Align(PointerSize)); 3568 OutStreamer->emitSymbolValue(CurrentPatchableFunctionEntrySym, PointerSize); 3569 } 3570} 3571 3572uint16_t AsmPrinter::getDwarfVersion() const { 3573 return OutStreamer->getContext().getDwarfVersion(); 3574} 3575 3576void AsmPrinter::setDwarfVersion(uint16_t Version) { 3577 OutStreamer->getContext().setDwarfVersion(Version); 3578} 3579 3580bool AsmPrinter::isDwarf64() const { 3581 return OutStreamer->getContext().getDwarfFormat() == dwarf::DWARF64; 3582} 3583 3584unsigned int AsmPrinter::getDwarfOffsetByteSize() const { 3585 return dwarf::getDwarfOffsetByteSize( 3586 OutStreamer->getContext().getDwarfFormat()); 3587} 3588 3589unsigned int AsmPrinter::getUnitLengthFieldByteSize() const { 3590 return dwarf::getUnitLengthFieldByteSize( 3591 OutStreamer->getContext().getDwarfFormat()); 3592} 3593