1 //===-- AsmPrinterInlineAsm.cpp - AsmPrinter Inline Asm Handling ----------===// 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 inline assembler pieces of the AsmPrinter class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ADT/SmallString.h" 14 #include "llvm/ADT/Twine.h" 15 #include "llvm/CodeGen/AsmPrinter.h" 16 #include "llvm/CodeGen/MachineBasicBlock.h" 17 #include "llvm/CodeGen/MachineFunction.h" 18 #include "llvm/CodeGen/MachineModuleInfo.h" 19 #include "llvm/CodeGen/TargetInstrInfo.h" 20 #include "llvm/CodeGen/TargetRegisterInfo.h" 21 #include "llvm/IR/Constants.h" 22 #include "llvm/IR/DataLayout.h" 23 #include "llvm/IR/InlineAsm.h" 24 #include "llvm/IR/LLVMContext.h" 25 #include "llvm/IR/Module.h" 26 #include "llvm/MC/MCAsmInfo.h" 27 #include "llvm/MC/MCParser/MCTargetAsmParser.h" 28 #include "llvm/MC/MCStreamer.h" 29 #include "llvm/MC/MCSubtargetInfo.h" 30 #include "llvm/MC/MCSymbol.h" 31 #include "llvm/Support/ErrorHandling.h" 32 #include "llvm/Support/MemoryBuffer.h" 33 #include "llvm/Support/SourceMgr.h" 34 #include "llvm/Support/TargetRegistry.h" 35 #include "llvm/Support/raw_ostream.h" 36 #include "llvm/Target/TargetMachine.h" 37 using namespace llvm; 38 39 #define DEBUG_TYPE "asm-printer" 40 41 /// srcMgrDiagHandler - This callback is invoked when the SourceMgr for an 42 /// inline asm has an error in it. diagInfo is a pointer to the SrcMgrDiagInfo 43 /// struct above. 44 static void srcMgrDiagHandler(const SMDiagnostic &Diag, void *diagInfo) { 45 AsmPrinter::SrcMgrDiagInfo *DiagInfo = 46 static_cast<AsmPrinter::SrcMgrDiagInfo *>(diagInfo); 47 assert(DiagInfo && "Diagnostic context not passed down?"); 48 49 // Look up a LocInfo for the buffer this diagnostic is coming from. 50 unsigned BufNum = DiagInfo->SrcMgr.FindBufferContainingLoc(Diag.getLoc()); 51 const MDNode *LocInfo = nullptr; 52 if (BufNum > 0 && BufNum <= DiagInfo->LocInfos.size()) 53 LocInfo = DiagInfo->LocInfos[BufNum-1]; 54 55 // If the inline asm had metadata associated with it, pull out a location 56 // cookie corresponding to which line the error occurred on. 57 unsigned LocCookie = 0; 58 if (LocInfo) { 59 unsigned ErrorLine = Diag.getLineNo()-1; 60 if (ErrorLine >= LocInfo->getNumOperands()) 61 ErrorLine = 0; 62 63 if (LocInfo->getNumOperands() != 0) 64 if (const ConstantInt *CI = 65 mdconst::dyn_extract<ConstantInt>(LocInfo->getOperand(ErrorLine))) 66 LocCookie = CI->getZExtValue(); 67 } 68 69 DiagInfo->DiagHandler(Diag, DiagInfo->DiagContext, LocCookie); 70 } 71 72 unsigned AsmPrinter::addInlineAsmDiagBuffer(StringRef AsmStr, 73 const MDNode *LocMDNode) const { 74 if (!DiagInfo) { 75 DiagInfo = make_unique<SrcMgrDiagInfo>(); 76 77 MCContext &Context = MMI->getContext(); 78 Context.setInlineSourceManager(&DiagInfo->SrcMgr); 79 80 LLVMContext &LLVMCtx = MMI->getModule()->getContext(); 81 if (LLVMCtx.getInlineAsmDiagnosticHandler()) { 82 DiagInfo->DiagHandler = LLVMCtx.getInlineAsmDiagnosticHandler(); 83 DiagInfo->DiagContext = LLVMCtx.getInlineAsmDiagnosticContext(); 84 DiagInfo->SrcMgr.setDiagHandler(srcMgrDiagHandler, DiagInfo.get()); 85 } 86 } 87 88 SourceMgr &SrcMgr = DiagInfo->SrcMgr; 89 90 std::unique_ptr<MemoryBuffer> Buffer; 91 // The inline asm source manager will outlive AsmStr, so make a copy of the 92 // string for SourceMgr to own. 93 Buffer = MemoryBuffer::getMemBufferCopy(AsmStr, "<inline asm>"); 94 95 // Tell SrcMgr about this buffer, it takes ownership of the buffer. 96 unsigned BufNum = SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc()); 97 98 // Store LocMDNode in DiagInfo, using BufNum as an identifier. 99 if (LocMDNode) { 100 DiagInfo->LocInfos.resize(BufNum); 101 DiagInfo->LocInfos[BufNum - 1] = LocMDNode; 102 } 103 104 return BufNum; 105 } 106 107 108 /// EmitInlineAsm - Emit a blob of inline asm to the output streamer. 109 void AsmPrinter::EmitInlineAsm(StringRef Str, const MCSubtargetInfo &STI, 110 const MCTargetOptions &MCOptions, 111 const MDNode *LocMDNode, 112 InlineAsm::AsmDialect Dialect) const { 113 assert(!Str.empty() && "Can't emit empty inline asm block"); 114 115 // Remember if the buffer is nul terminated or not so we can avoid a copy. 116 bool isNullTerminated = Str.back() == 0; 117 if (isNullTerminated) 118 Str = Str.substr(0, Str.size()-1); 119 120 // If the output streamer does not have mature MC support or the integrated 121 // assembler has been disabled, just emit the blob textually. 122 // Otherwise parse the asm and emit it via MC support. 123 // This is useful in case the asm parser doesn't handle something but the 124 // system assembler does. 125 const MCAsmInfo *MCAI = TM.getMCAsmInfo(); 126 assert(MCAI && "No MCAsmInfo"); 127 if (!MCAI->useIntegratedAssembler() && 128 !OutStreamer->isIntegratedAssemblerRequired()) { 129 emitInlineAsmStart(); 130 OutStreamer->EmitRawText(Str); 131 emitInlineAsmEnd(STI, nullptr); 132 return; 133 } 134 135 unsigned BufNum = addInlineAsmDiagBuffer(Str, LocMDNode); 136 DiagInfo->SrcMgr.setIncludeDirs(MCOptions.IASSearchPaths); 137 138 std::unique_ptr<MCAsmParser> Parser(createMCAsmParser( 139 DiagInfo->SrcMgr, OutContext, *OutStreamer, *MAI, BufNum)); 140 141 // Do not use assembler-level information for parsing inline assembly. 142 OutStreamer->setUseAssemblerInfoForParsing(false); 143 144 // We create a new MCInstrInfo here since we might be at the module level 145 // and not have a MachineFunction to initialize the TargetInstrInfo from and 146 // we only need MCInstrInfo for asm parsing. We create one unconditionally 147 // because it's not subtarget dependent. 148 std::unique_ptr<MCInstrInfo> MII(TM.getTarget().createMCInstrInfo()); 149 std::unique_ptr<MCTargetAsmParser> TAP(TM.getTarget().createMCAsmParser( 150 STI, *Parser, *MII, MCOptions)); 151 if (!TAP) 152 report_fatal_error("Inline asm not supported by this streamer because" 153 " we don't have an asm parser for this target\n"); 154 Parser->setAssemblerDialect(Dialect); 155 Parser->setTargetParser(*TAP.get()); 156 // Enable lexing Masm binary and hex integer literals in intel inline 157 // assembly. 158 if (Dialect == InlineAsm::AD_Intel) 159 Parser->getLexer().setLexMasmIntegers(true); 160 161 emitInlineAsmStart(); 162 // Don't implicitly switch to the text section before the asm. 163 int Res = Parser->Run(/*NoInitialTextSection*/ true, 164 /*NoFinalize*/ true); 165 emitInlineAsmEnd(STI, &TAP->getSTI()); 166 167 if (Res && !DiagInfo->DiagHandler) 168 report_fatal_error("Error parsing inline asm\n"); 169 } 170 171 static void EmitMSInlineAsmStr(const char *AsmStr, const MachineInstr *MI, 172 MachineModuleInfo *MMI, AsmPrinter *AP, 173 unsigned LocCookie, raw_ostream &OS) { 174 // Switch to the inline assembly variant. 175 OS << "\t.intel_syntax\n\t"; 176 177 const char *LastEmitted = AsmStr; // One past the last character emitted. 178 unsigned NumOperands = MI->getNumOperands(); 179 180 while (*LastEmitted) { 181 switch (*LastEmitted) { 182 default: { 183 // Not a special case, emit the string section literally. 184 const char *LiteralEnd = LastEmitted+1; 185 while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && 186 *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') 187 ++LiteralEnd; 188 189 OS.write(LastEmitted, LiteralEnd-LastEmitted); 190 LastEmitted = LiteralEnd; 191 break; 192 } 193 case '\n': 194 ++LastEmitted; // Consume newline character. 195 OS << '\n'; // Indent code with newline. 196 break; 197 case '$': { 198 ++LastEmitted; // Consume '$' character. 199 bool Done = true; 200 201 // Handle escapes. 202 switch (*LastEmitted) { 203 default: Done = false; break; 204 case '$': 205 ++LastEmitted; // Consume second '$' character. 206 break; 207 } 208 if (Done) break; 209 210 // If we have ${:foo}, then this is not a real operand reference, it is a 211 // "magic" string reference, just like in .td files. Arrange to call 212 // PrintSpecial. 213 if (LastEmitted[0] == '{' && LastEmitted[1] == ':') { 214 LastEmitted += 2; 215 const char *StrStart = LastEmitted; 216 const char *StrEnd = strchr(StrStart, '}'); 217 if (!StrEnd) 218 report_fatal_error("Unterminated ${:foo} operand in inline asm" 219 " string: '" + Twine(AsmStr) + "'"); 220 221 std::string Val(StrStart, StrEnd); 222 AP->PrintSpecial(MI, OS, Val.c_str()); 223 LastEmitted = StrEnd+1; 224 break; 225 } 226 227 const char *IDStart = LastEmitted; 228 const char *IDEnd = IDStart; 229 while (*IDEnd >= '0' && *IDEnd <= '9') ++IDEnd; 230 231 unsigned Val; 232 if (StringRef(IDStart, IDEnd-IDStart).getAsInteger(10, Val)) 233 report_fatal_error("Bad $ operand number in inline asm string: '" + 234 Twine(AsmStr) + "'"); 235 LastEmitted = IDEnd; 236 237 if (Val >= NumOperands-1) 238 report_fatal_error("Invalid $ operand number in inline asm string: '" + 239 Twine(AsmStr) + "'"); 240 241 // Okay, we finally have a value number. Ask the target to print this 242 // operand! 243 unsigned OpNo = InlineAsm::MIOp_FirstOperand; 244 245 bool Error = false; 246 247 // Scan to find the machine operand number for the operand. 248 for (; Val; --Val) { 249 if (OpNo >= MI->getNumOperands()) break; 250 unsigned OpFlags = MI->getOperand(OpNo).getImm(); 251 OpNo += InlineAsm::getNumOperandRegisters(OpFlags) + 1; 252 } 253 254 // We may have a location metadata attached to the end of the 255 // instruction, and at no point should see metadata at any 256 // other point while processing. It's an error if so. 257 if (OpNo >= MI->getNumOperands() || 258 MI->getOperand(OpNo).isMetadata()) { 259 Error = true; 260 } else { 261 unsigned OpFlags = MI->getOperand(OpNo).getImm(); 262 ++OpNo; // Skip over the ID number. 263 264 if (InlineAsm::isMemKind(OpFlags)) { 265 Error = AP->PrintAsmMemoryOperand(MI, OpNo, /*Modifier*/ nullptr, OS); 266 } else { 267 Error = AP->PrintAsmOperand(MI, OpNo, /*Modifier*/ nullptr, OS); 268 } 269 } 270 if (Error) { 271 std::string msg; 272 raw_string_ostream Msg(msg); 273 Msg << "invalid operand in inline asm: '" << AsmStr << "'"; 274 MMI->getModule()->getContext().emitError(LocCookie, Msg.str()); 275 } 276 break; 277 } 278 } 279 } 280 OS << "\n\t.att_syntax\n" << (char)0; // null terminate string. 281 } 282 283 static void EmitGCCInlineAsmStr(const char *AsmStr, const MachineInstr *MI, 284 MachineModuleInfo *MMI, int AsmPrinterVariant, 285 AsmPrinter *AP, unsigned LocCookie, 286 raw_ostream &OS) { 287 int CurVariant = -1; // The number of the {.|.|.} region we are in. 288 const char *LastEmitted = AsmStr; // One past the last character emitted. 289 unsigned NumOperands = MI->getNumOperands(); 290 291 OS << '\t'; 292 293 while (*LastEmitted) { 294 switch (*LastEmitted) { 295 default: { 296 // Not a special case, emit the string section literally. 297 const char *LiteralEnd = LastEmitted+1; 298 while (*LiteralEnd && *LiteralEnd != '{' && *LiteralEnd != '|' && 299 *LiteralEnd != '}' && *LiteralEnd != '$' && *LiteralEnd != '\n') 300 ++LiteralEnd; 301 if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 302 OS.write(LastEmitted, LiteralEnd-LastEmitted); 303 LastEmitted = LiteralEnd; 304 break; 305 } 306 case '\n': 307 ++LastEmitted; // Consume newline character. 308 OS << '\n'; // Indent code with newline. 309 break; 310 case '$': { 311 ++LastEmitted; // Consume '$' character. 312 bool Done = true; 313 314 // Handle escapes. 315 switch (*LastEmitted) { 316 default: Done = false; break; 317 case '$': // $$ -> $ 318 if (CurVariant == -1 || CurVariant == AsmPrinterVariant) 319 OS << '$'; 320 ++LastEmitted; // Consume second '$' character. 321 break; 322 case '(': // $( -> same as GCC's { character. 323 ++LastEmitted; // Consume '(' character. 324 if (CurVariant != -1) 325 report_fatal_error("Nested variants found in inline asm string: '" + 326 Twine(AsmStr) + "'"); 327 CurVariant = 0; // We're in the first variant now. 328 break; 329 case '|': 330 ++LastEmitted; // consume '|' character. 331 if (CurVariant == -1) 332 OS << '|'; // this is gcc's behavior for | outside a variant 333 else 334 ++CurVariant; // We're in the next variant. 335 break; 336 case ')': // $) -> same as GCC's } char. 337 ++LastEmitted; // consume ')' character. 338 if (CurVariant == -1) 339 OS << '}'; // this is gcc's behavior for } outside a variant 340 else 341 CurVariant = -1; 342 break; 343 } 344 if (Done) break; 345 346 bool HasCurlyBraces = false; 347 if (*LastEmitted == '{') { // ${variable} 348 ++LastEmitted; // Consume '{' character. 349 HasCurlyBraces = true; 350 } 351 352 // If we have ${:foo}, then this is not a real operand reference, it is a 353 // "magic" string reference, just like in .td files. Arrange to call 354 // PrintSpecial. 355 if (HasCurlyBraces && *LastEmitted == ':') { 356 ++LastEmitted; 357 const char *StrStart = LastEmitted; 358 const char *StrEnd = strchr(StrStart, '}'); 359 if (!StrEnd) 360 report_fatal_error("Unterminated ${:foo} operand in inline asm" 361 " string: '" + Twine(AsmStr) + "'"); 362 363 std::string Val(StrStart, StrEnd); 364 AP->PrintSpecial(MI, OS, Val.c_str()); 365 LastEmitted = StrEnd+1; 366 break; 367 } 368 369 const char *IDStart = LastEmitted; 370 const char *IDEnd = IDStart; 371 while (*IDEnd >= '0' && *IDEnd <= '9') ++IDEnd; 372 373 unsigned Val; 374 if (StringRef(IDStart, IDEnd-IDStart).getAsInteger(10, Val)) 375 report_fatal_error("Bad $ operand number in inline asm string: '" + 376 Twine(AsmStr) + "'"); 377 LastEmitted = IDEnd; 378 379 char Modifier[2] = { 0, 0 }; 380 381 if (HasCurlyBraces) { 382 // If we have curly braces, check for a modifier character. This 383 // supports syntax like ${0:u}, which correspond to "%u0" in GCC asm. 384 if (*LastEmitted == ':') { 385 ++LastEmitted; // Consume ':' character. 386 if (*LastEmitted == 0) 387 report_fatal_error("Bad ${:} expression in inline asm string: '" + 388 Twine(AsmStr) + "'"); 389 390 Modifier[0] = *LastEmitted; 391 ++LastEmitted; // Consume modifier character. 392 } 393 394 if (*LastEmitted != '}') 395 report_fatal_error("Bad ${} expression in inline asm string: '" + 396 Twine(AsmStr) + "'"); 397 ++LastEmitted; // Consume '}' character. 398 } 399 400 if (Val >= NumOperands-1) 401 report_fatal_error("Invalid $ operand number in inline asm string: '" + 402 Twine(AsmStr) + "'"); 403 404 // Okay, we finally have a value number. Ask the target to print this 405 // operand! 406 if (CurVariant == -1 || CurVariant == AsmPrinterVariant) { 407 unsigned OpNo = InlineAsm::MIOp_FirstOperand; 408 409 bool Error = false; 410 411 // Scan to find the machine operand number for the operand. 412 for (; Val; --Val) { 413 if (OpNo >= MI->getNumOperands()) break; 414 unsigned OpFlags = MI->getOperand(OpNo).getImm(); 415 OpNo += InlineAsm::getNumOperandRegisters(OpFlags) + 1; 416 } 417 418 // We may have a location metadata attached to the end of the 419 // instruction, and at no point should see metadata at any 420 // other point while processing. It's an error if so. 421 if (OpNo >= MI->getNumOperands() || 422 MI->getOperand(OpNo).isMetadata()) { 423 Error = true; 424 } else { 425 unsigned OpFlags = MI->getOperand(OpNo).getImm(); 426 ++OpNo; // Skip over the ID number. 427 428 // FIXME: Shouldn't arch-independent output template handling go into 429 // PrintAsmOperand? 430 if (Modifier[0] == 'l') { // Labels are target independent. 431 if (MI->getOperand(OpNo).isBlockAddress()) { 432 const BlockAddress *BA = MI->getOperand(OpNo).getBlockAddress(); 433 MCSymbol *Sym = AP->GetBlockAddressSymbol(BA); 434 Sym->print(OS, AP->MAI); 435 MMI->getContext().registerInlineAsmLabel(Sym); 436 } else if (MI->getOperand(OpNo).isMBB()) { 437 const MCSymbol *Sym = MI->getOperand(OpNo).getMBB()->getSymbol(); 438 Sym->print(OS, AP->MAI); 439 } else { 440 Error = true; 441 } 442 } else { 443 if (InlineAsm::isMemKind(OpFlags)) { 444 Error = AP->PrintAsmMemoryOperand( 445 MI, OpNo, Modifier[0] ? Modifier : nullptr, OS); 446 } else { 447 Error = AP->PrintAsmOperand(MI, OpNo, 448 Modifier[0] ? Modifier : nullptr, OS); 449 } 450 } 451 } 452 if (Error) { 453 std::string msg; 454 raw_string_ostream Msg(msg); 455 Msg << "invalid operand in inline asm: '" << AsmStr << "'"; 456 MMI->getModule()->getContext().emitError(LocCookie, Msg.str()); 457 } 458 } 459 break; 460 } 461 } 462 } 463 OS << '\n' << (char)0; // null terminate string. 464 } 465 466 /// EmitInlineAsm - This method formats and emits the specified machine 467 /// instruction that is an inline asm. 468 void AsmPrinter::EmitInlineAsm(const MachineInstr *MI) const { 469 assert(MI->isInlineAsm() && "printInlineAsm only works on inline asms"); 470 471 // Count the number of register definitions to find the asm string. 472 unsigned NumDefs = 0; 473 for (; MI->getOperand(NumDefs).isReg() && MI->getOperand(NumDefs).isDef(); 474 ++NumDefs) 475 assert(NumDefs != MI->getNumOperands()-2 && "No asm string?"); 476 477 assert(MI->getOperand(NumDefs).isSymbol() && "No asm string?"); 478 479 // Disassemble the AsmStr, printing out the literal pieces, the operands, etc. 480 const char *AsmStr = MI->getOperand(NumDefs).getSymbolName(); 481 482 // If this asmstr is empty, just print the #APP/#NOAPP markers. 483 // These are useful to see where empty asm's wound up. 484 if (AsmStr[0] == 0) { 485 OutStreamer->emitRawComment(MAI->getInlineAsmStart()); 486 OutStreamer->emitRawComment(MAI->getInlineAsmEnd()); 487 return; 488 } 489 490 // Emit the #APP start marker. This has to happen even if verbose-asm isn't 491 // enabled, so we use emitRawComment. 492 OutStreamer->emitRawComment(MAI->getInlineAsmStart()); 493 494 // Get the !srcloc metadata node if we have it, and decode the loc cookie from 495 // it. 496 unsigned LocCookie = 0; 497 const MDNode *LocMD = nullptr; 498 for (unsigned i = MI->getNumOperands(); i != 0; --i) { 499 if (MI->getOperand(i-1).isMetadata() && 500 (LocMD = MI->getOperand(i-1).getMetadata()) && 501 LocMD->getNumOperands() != 0) { 502 if (const ConstantInt *CI = 503 mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) { 504 LocCookie = CI->getZExtValue(); 505 break; 506 } 507 } 508 } 509 510 // Emit the inline asm to a temporary string so we can emit it through 511 // EmitInlineAsm. 512 SmallString<256> StringData; 513 raw_svector_ostream OS(StringData); 514 515 // The variant of the current asmprinter. 516 int AsmPrinterVariant = MAI->getAssemblerDialect(); 517 AsmPrinter *AP = const_cast<AsmPrinter*>(this); 518 if (MI->getInlineAsmDialect() == InlineAsm::AD_ATT) 519 EmitGCCInlineAsmStr(AsmStr, MI, MMI, AsmPrinterVariant, AP, LocCookie, OS); 520 else 521 EmitMSInlineAsmStr(AsmStr, MI, MMI, AP, LocCookie, OS); 522 523 // Emit warnings if we use reserved registers on the clobber list, as 524 // that might give surprising results. 525 std::vector<std::string> RestrRegs; 526 // Start with the first operand descriptor, and iterate over them. 527 for (unsigned I = InlineAsm::MIOp_FirstOperand, NumOps = MI->getNumOperands(); 528 I < NumOps; ++I) { 529 const MachineOperand &MO = MI->getOperand(I); 530 if (MO.isImm()) { 531 unsigned Flags = MO.getImm(); 532 const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo(); 533 if (InlineAsm::getKind(Flags) == InlineAsm::Kind_Clobber && 534 !TRI->isAsmClobberable(*MF, MI->getOperand(I + 1).getReg())) { 535 RestrRegs.push_back(TRI->getName(MI->getOperand(I + 1).getReg())); 536 } 537 // Skip to one before the next operand descriptor, if it exists. 538 I += InlineAsm::getNumOperandRegisters(Flags); 539 } 540 } 541 542 if (!RestrRegs.empty()) { 543 unsigned BufNum = addInlineAsmDiagBuffer(OS.str(), LocMD); 544 auto &SrcMgr = DiagInfo->SrcMgr; 545 SMLoc Loc = SMLoc::getFromPointer( 546 SrcMgr.getMemoryBuffer(BufNum)->getBuffer().begin()); 547 548 std::string Msg = "inline asm clobber list contains reserved registers: "; 549 for (auto I = RestrRegs.begin(), E = RestrRegs.end(); I != E; I++) { 550 if(I != RestrRegs.begin()) 551 Msg += ", "; 552 Msg += *I; 553 } 554 std::string Note = "Reserved registers on the clobber list may not be " 555 "preserved across the asm statement, and clobbering them may " 556 "lead to undefined behaviour."; 557 SrcMgr.PrintMessage(Loc, SourceMgr::DK_Warning, Msg); 558 SrcMgr.PrintMessage(Loc, SourceMgr::DK_Note, Note); 559 } 560 561 EmitInlineAsm(OS.str(), getSubtargetInfo(), TM.Options.MCOptions, LocMD, 562 MI->getInlineAsmDialect()); 563 564 // Emit the #NOAPP end marker. This has to happen even if verbose-asm isn't 565 // enabled, so we use emitRawComment. 566 OutStreamer->emitRawComment(MAI->getInlineAsmEnd()); 567 } 568 569 570 /// PrintSpecial - Print information related to the specified machine instr 571 /// that is independent of the operand, and may be independent of the instr 572 /// itself. This can be useful for portably encoding the comment character 573 /// or other bits of target-specific knowledge into the asmstrings. The 574 /// syntax used is ${:comment}. Targets can override this to add support 575 /// for their own strange codes. 576 void AsmPrinter::PrintSpecial(const MachineInstr *MI, raw_ostream &OS, 577 const char *Code) const { 578 if (!strcmp(Code, "private")) { 579 const DataLayout &DL = MF->getDataLayout(); 580 OS << DL.getPrivateGlobalPrefix(); 581 } else if (!strcmp(Code, "comment")) { 582 OS << MAI->getCommentString(); 583 } else if (!strcmp(Code, "uid")) { 584 // Comparing the address of MI isn't sufficient, because machineinstrs may 585 // be allocated to the same address across functions. 586 587 // If this is a new LastFn instruction, bump the counter. 588 if (LastMI != MI || LastFn != getFunctionNumber()) { 589 ++Counter; 590 LastMI = MI; 591 LastFn = getFunctionNumber(); 592 } 593 OS << Counter; 594 } else { 595 std::string msg; 596 raw_string_ostream Msg(msg); 597 Msg << "Unknown special formatter '" << Code 598 << "' for machine instr: " << *MI; 599 report_fatal_error(Msg.str()); 600 } 601 } 602 603 void AsmPrinter::PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS) { 604 assert(MO.isGlobal() && "caller should check MO.isGlobal"); 605 getSymbol(MO.getGlobal())->print(OS, MAI); 606 printOffset(MO.getOffset(), OS); 607 } 608 609 /// PrintAsmOperand - Print the specified operand of MI, an INLINEASM 610 /// instruction, using the specified assembler variant. Targets should 611 /// override this to format as appropriate for machine specific ExtraCodes 612 /// or when the arch-independent handling would be too complex otherwise. 613 bool AsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 614 const char *ExtraCode, raw_ostream &O) { 615 // Does this asm operand have a single letter operand modifier? 616 if (ExtraCode && ExtraCode[0]) { 617 if (ExtraCode[1] != 0) return true; // Unknown modifier. 618 619 // https://gcc.gnu.org/onlinedocs/gccint/Output-Template.html 620 const MachineOperand &MO = MI->getOperand(OpNo); 621 switch (ExtraCode[0]) { 622 default: 623 return true; // Unknown modifier. 624 case 'a': // Print as memory address. 625 if (MO.isReg()) { 626 PrintAsmMemoryOperand(MI, OpNo, nullptr, O); 627 return false; 628 } 629 LLVM_FALLTHROUGH; // GCC allows '%a' to behave like '%c' with immediates. 630 case 'c': // Substitute immediate value without immediate syntax 631 if (MO.isImm()) { 632 O << MO.getImm(); 633 return false; 634 } 635 if (MO.isGlobal()) { 636 PrintSymbolOperand(MO, O); 637 return false; 638 } 639 return true; 640 case 'n': // Negate the immediate constant. 641 if (!MO.isImm()) 642 return true; 643 O << -MO.getImm(); 644 return false; 645 case 's': // The GCC deprecated s modifier 646 if (!MO.isImm()) 647 return true; 648 O << ((32 - MO.getImm()) & 31); 649 return false; 650 } 651 } 652 return true; 653 } 654 655 bool AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 656 const char *ExtraCode, raw_ostream &O) { 657 // Target doesn't support this yet! 658 return true; 659 } 660 661 void AsmPrinter::emitInlineAsmStart() const {} 662 663 void AsmPrinter::emitInlineAsmEnd(const MCSubtargetInfo &StartInfo, 664 const MCSubtargetInfo *EndInfo) const {} 665