reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

   34   MCTargetStreamer &TS = *Asm->OutStreamer->getTargetStreamer();
   49         Asm->OutStreamer->EmitCFISections(false, true);
   54     Asm->OutStreamer->EmitCFIStartProc(false);
   78       Asm->OutStreamer->EmitSymbolAttribute(PerSym, MCSA_Global);
   99   bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
  104     Asm->OutStreamer->AddComment(">> Catch TypeInfos <<");
  105     Asm->OutStreamer->AddBlankLine();
  111       Asm->OutStreamer->AddComment("TypeInfo " + Twine(Entry--));
  115   Asm->OutStreamer->EmitLabel(TTBaseLabel);
  119     Asm->OutStreamer->AddComment(">> Filter TypeInfos <<");
  120     Asm->OutStreamer->AddBlankLine();
  129         Asm->OutStreamer->AddComment("FilterInfo " + Twine(Entry));

  256       Asm->OutStreamer->AddComment("Hash in Bucket " + Twine(BucketIdx));
  273       Asm->OutStreamer->AddComment("Offset in Bucket " + Twine(i));
  280   Asm->OutStreamer->AddComment("Header Magic");
  282   Asm->OutStreamer->AddComment("Header Version");
  284   Asm->OutStreamer->AddComment("Header Hash Function");
  286   Asm->OutStreamer->AddComment("Header Bucket Count");
  288   Asm->OutStreamer->AddComment("Header Hash Count");
  290   Asm->OutStreamer->AddComment("Header Data Length");
  295   Asm->OutStreamer->AddComment("HeaderData Die Offset Base");
  297   Asm->OutStreamer->AddComment("HeaderData Atom Count");
  301     Asm->OutStreamer->AddComment(dwarf::AtomTypeString(A.Type));
  303     Asm->OutStreamer->AddComment(dwarf::FormEncodingString(A.Form));
  312     Asm->OutStreamer->AddComment("Bucket " + Twine(i));
  340       Asm->OutStreamer->EmitLabel(Hash->Sym);
  341       Asm->OutStreamer->AddComment(Hash->Name.getString());
  343       Asm->OutStreamer->AddComment("Num DIEs");
  370   Asm->OutStreamer->AddComment("Header: unit length");
  373   Asm->OutStreamer->EmitLabel(Ctx.ContributionStart);
  374   Asm->OutStreamer->AddComment("Header: version");
  376   Asm->OutStreamer->AddComment("Header: padding");
  378   Asm->OutStreamer->AddComment("Header: compilation unit count");
  380   Asm->OutStreamer->AddComment("Header: local type unit count");
  382   Asm->OutStreamer->AddComment("Header: foreign type unit count");
  384   Asm->OutStreamer->AddComment("Header: bucket count");
  386   Asm->OutStreamer->AddComment("Header: name count");
  388   Asm->OutStreamer->AddComment("Header: abbreviation table size");
  390   Asm->OutStreamer->AddComment("Header: augmentation string size");
  393   Asm->OutStreamer->AddComment("Header: augmentation string");
  394   Asm->OutStreamer->EmitBytes({AugmentationString, AugmentationStringSize});
  427     Asm->OutStreamer->AddComment("Compilation unit " + Twine(CU.index()));
  436     Asm->OutStreamer->AddComment("Bucket " + Twine(Bucket.index()));
  447       Asm->OutStreamer->AddComment("String in Bucket " + Twine(Bucket.index()) +
  456   Asm->OutStreamer->EmitLabel(AbbrevStart);
  458     Asm->OutStreamer->AddComment("Abbrev code");
  461     Asm->OutStreamer->AddComment(dwarf::TagString(Abbrev.first));
  472   Asm->OutStreamer->EmitLabel(AbbrevEnd);
  483     Asm->OutStreamer->AddComment(dwarf::IndexString(AttrEnc.Index));
  501   Asm->OutStreamer->EmitLabel(EntryPool);
  505       Asm->OutStreamer->EmitLabel(Hash->Sym);
  508       Asm->OutStreamer->AddComment("End of list: " + Hash->Name.getString());
  540   Asm->OutStreamer->EmitValueToAlignment(4, 0);
  541   Asm->OutStreamer->EmitLabel(ContributionEnd);
  571   Asm->OutStreamer->SwitchSection(

   32   Asm.OutStreamer->AddComment("Length of contribution");
   35   Asm.OutStreamer->EmitLabel(BeginLabel);
   36   Asm.OutStreamer->AddComment("DWARF version number");
   38   Asm.OutStreamer->AddComment("Address size");
   40   Asm.OutStreamer->AddComment("Segment selector size");
   52   Asm.OutStreamer->SwitchSection(AddrSection);
   61   Asm.OutStreamer->EmitLabel(AddressTableBaseSym);
   73     Asm.OutStreamer->EmitValue(Entry, Asm.getDataLayout().getPointerSize());
   76     Asm.OutStreamer->EmitLabel(EndLabel);

  188   VerboseAsm = OutStreamer->isVerboseAsm();
  236   assert(OutStreamer->hasRawTextSupport() && "Expected assembly output mode.");
  242   return OutStreamer->getCurrentSectionOnly();
  264   OutStreamer->InitSections(false);
  275   OutStreamer->EmitVersionForTarget(Target, M.getSDKVersion());
  284     OutStreamer->EmitFileDirective(
  301     OutStreamer->AddComment("Start of file scope inline assembly");
  302     OutStreamer->AddBlankLine();
  305     OutStreamer->AddComment("End of file scope inline assembly");
  306     OutStreamer->AddBlankLine();
  405       OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Global);
  409         OutStreamer->EmitSymbolAttribute(GVSym, MCSA_WeakDefinition);
  411         OutStreamer->EmitSymbolAttribute(GVSym, MCSA_WeakDefAutoPrivate);
  414       OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Global);
  418       OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Weak);
  423     OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Global);
  429       OutStreamer->EmitSymbolAttribute(GVSym, MCSA_LGlobal);
  472       GV->printAsOperand(OutStreamer->GetCommentOS(),
  474       OutStreamer->GetCommentOS() << '\n';
  495     OutStreamer->EmitSymbolAttribute(EmittedSym, MCSA_ELF_TypeObject);
  520     OutStreamer->EmitCommonSymbol(GVSym, Size,
  536     OutStreamer->EmitZerofill(TheSection, GVSym, Size, Alignment.value());
  555       OutStreamer->EmitLocalCommonSymbol(GVSym, Size, Alignment.value());
  560     OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Local);
  564     OutStreamer->EmitCommonSymbol(GVSym, Size,
  586       OutStreamer->EmitTBSSSymbol(TheSection, MangSym, Size, Alignment.value());
  588       OutStreamer->SwitchSection(TheSection);
  591       OutStreamer->EmitLabel(MangSym);
  597     OutStreamer->AddBlankLine();
  602     OutStreamer->SwitchSection(TLVSect);
  605     OutStreamer->EmitLabel(GVSym);
  612     OutStreamer->EmitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"),
  614     OutStreamer->EmitIntValue(0, PtrSize);
  615     OutStreamer->EmitSymbolValue(MangSym, PtrSize);
  617     OutStreamer->AddBlankLine();
  623   OutStreamer->SwitchSection(TheSection);
  628   OutStreamer->EmitLabel(EmittedInitSym);
  634     OutStreamer->emitELFSize(EmittedInitSym,
  637   OutStreamer->AddBlankLine();
  645   OutStreamer->EmitValue(Value, Size);
  654     OutStreamer->GetCommentOS()
  662   OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(&F, TM));
  674     OutStreamer->EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
  677     OutStreamer->EmitSymbolAttribute(CurrentFnSym, MCSA_Cold);
  680     F.printAsOperand(OutStreamer->GetCommentOS(),
  682     OutStreamer->GetCommentOS() << '\n';
  693       OutStreamer->EmitLabel(PrefixSym);
  698       OutStreamer->EmitSymbolAttribute(CurrentFnSym, MCSA_AltEntry);
  719     OutStreamer->AddComment("Address taken block that was later removed");
  720     OutStreamer->EmitLabel(DeadBlockSyms[i]);
  726       OutStreamer->EmitLabel(CurPos);
  727       OutStreamer->EmitAssignment(CurrentFnBegin,
  730       OutStreamer->EmitLabel(CurrentFnBegin);
  760   return OutStreamer->EmitLabel(CurrentFnSym);
  800   OutStreamer->AddComment(OS.str());
  801   OutStreamer->AddBlankLine();
  814   AP.OutStreamer->AddComment(OS.str());
  815   AP.OutStreamer->AddBlankLine();
  892       AP.OutStreamer->emitRawComment(OS.str());
  904   AP.OutStreamer->emitRawComment(OS.str());
  929   AP.OutStreamer->emitRawComment(OS.str());
  979   OutStreamer->EmitAssignment(FrameAllocSym,
  997   OutStreamer->PushSection();
  998   OutStreamer->SwitchSection(StackSizeSection);
 1002   OutStreamer->EmitSymbolValue(FunctionSymbol, TM.getProgramPointerSize());
 1003   OutStreamer->EmitULEB128IntValue(StackSize);
 1005   OutStreamer->PopSection();
 1065         OutStreamer->EmitLabel(S);
 1077         emitComments(MI, OutStreamer->GetCommentOS());
 1089         OutStreamer->EmitLabel(MI.getOperand(0).getMCSymbol());
 1120         OutStreamer->EmitLabel(S);
 1160       OutStreamer->AddComment("avoids zero-length function");
 1161       OutStreamer->EmitInstruction(Noop, getSubtargetInfo());
 1172     OutStreamer->AddComment("Address of block that was removed by CodeGen");
 1173     OutStreamer->EmitLabel(Sym);
 1183     OutStreamer->EmitLabel(CurrentFnEnd);
 1194     OutStreamer->emitELFSize(CurrentFnSym, SizeExp);
 1217     OutStreamer->GetCommentOS() << "-- End function\n";
 1219   OutStreamer->AddBlankLine();
 1306     OutStreamer->EmitSymbolAttribute(Name, MCSA_Global);
 1308     OutStreamer->EmitSymbolAttribute(Name, MCSA_WeakReference);
 1325     OutStreamer->EmitSymbolAttribute(Name, isa<GlobalIFunc>(GIS)
 1334     OutStreamer->EmitSymbolAttribute(Name, MCSA_AltEntry);
 1337   OutStreamer->EmitAssignment(Name, Expr);
 1350       OutStreamer->emitELFSize(Name, MCConstantExpr::create(Size, OutContext));
 1378   OutStreamer->SwitchSection(RemarksSection);
 1380   OutStreamer->EmitBinaryData(OS.str());
 1422   TLOF.emitModuleMetadata(*OutStreamer, M);
 1430       OutStreamer->SwitchSection(TLOF.getDataSection());
 1435         OutStreamer->EmitLabel(Stub.first);
 1436         OutStreamer->EmitSymbolValue(Stub.second.getPointer(),
 1454         OutStreamer->SwitchSection(OutContext.getCOFFSection(
 1461         OutStreamer->EmitSymbolAttribute(Stub.first, MCSA_Global);
 1462         OutStreamer->EmitLabel(Stub.first);
 1463         OutStreamer->EmitSymbolValue(Stub.second.getPointer(),
 1489       OutStreamer->EmitSymbolAttribute(getSymbol(&GO), MCSA_WeakReference);
 1493   OutStreamer->AddBlankLine();
 1533     OutStreamer->SwitchSection(ReadOnlySection);
 1537     OutStreamer->EmitLabel(AddrSymbol);
 1540     OutStreamer->EmitSymbolValue(GetExternalSymbolSymbol("__morestack"),
 1547     OutStreamer->SwitchSection(
 1550       OutStreamer->SwitchSection(
 1559       OutStreamer->SwitchSection(S);
 1571         OutStreamer->SwitchSection(TLOF.getDrectveSection());
 1572         OutStreamer->EmitBytes(Flags);
 1597             OutStreamer->SwitchSection(TLOF.getDrectveSection());
 1598             OutStreamer->EmitBytes(Flags);
 1608     OutStreamer->EmitAddrsig();
 1613         OutStreamer->EmitAddrsigSym(getSymbol(&GV));
 1624       OutStreamer->SwitchSection(OutContext.getELFSection(
 1626       OutStreamer->EmitBytes(GV.getPartition());
 1627       OutStreamer->EmitZeros(1);
 1628       OutStreamer->EmitValue(
 1640   OutStreamer->Finish();
 1641   OutStreamer->reset();
 1760         OutStreamer->SwitchSection(CPSections[i].S);
 1771       OutStreamer->EmitZeros(NewOffset - Offset);
 1776       OutStreamer->EmitLabel(Sym);
 1805     OutStreamer->SwitchSection(ReadOnlySection);
 1813     OutStreamer->EmitDataRegion(MCDR_DataRegionJT32);
 1836         OutStreamer->EmitAssignment(GetJTSetSymbol(JTI, MBB->getNumber()),
 1849       OutStreamer->EmitLabel(GetJTISymbol(JTI, true));
 1851     OutStreamer->EmitLabel(GetJTISymbol(JTI));
 1857     OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
 1884     OutStreamer->EmitGPRel32Value(MCSymbolRefExpr::create(MBBSym, OutContext));
 1893     OutStreamer->EmitGPRel64Value(MCSymbolRefExpr::create(MBBSym, OutContext));
 1921   OutStreamer->EmitValue(Value, EntrySize);
 1968       OutStreamer->EmitSymbolAttribute(getSymbol(GV), MCSA_NoDeadStrip);
 2042     OutStreamer->SwitchSection(OutputSection);
 2043     if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection())
 2043     if (OutStreamer->getCurrentSection() != OutStreamer->getPreviousSection())
 2059       OutStreamer->EmitIdent(S->getString());
 2073   OutStreamer->PushSection();
 2074   OutStreamer->SwitchSection(CommandLine);
 2075   OutStreamer->EmitZeros(1);
 2081     OutStreamer->EmitBytes(S->getString());
 2082     OutStreamer->EmitZeros(1);
 2084   OutStreamer->PopSection();
 2094   OutStreamer->EmitIntValue(Value, 1);
 2099   OutStreamer->EmitIntValue(Value, 2);
 2104   OutStreamer->EmitIntValue(Value, 4);
 2109   OutStreamer->EmitIntValue(Value, 8);
 2117   OutStreamer->emitAbsoluteSymbolDiff(Hi, Lo, Size);
 2127     OutStreamer->EmitCOFFSecRel32(Label, Offset);
 2129       OutStreamer->EmitZeros(Size - 4);
 2139   OutStreamer->EmitValue(Expr, Size);
 2156     OutStreamer->EmitCodeAlignment(Alignment.value());
 2158     OutStreamer->EmitValueToAlignment(Alignment.value());
 2383       return AP.OutStreamer->emitFill(Bytes, Value);
 2388     return AP.OutStreamer->EmitBytes(CDS->getAsString());
 2395         AP.OutStreamer->GetCommentOS() << format("0x%" PRIx64 "\n",
 2397       AP.OutStreamer->EmitIntValue(CDS->getElementAsInteger(i),
 2411     AP.OutStreamer->EmitZeros(Padding);
 2423     AP.OutStreamer->emitFill(Bytes, Value);
 2442     AP.OutStreamer->EmitZeros(Padding);
 2467     AP.OutStreamer->EmitZeros(PadSize);
 2482     ET->print(AP.OutStreamer->GetCommentOS());
 2483     AP.OutStreamer->GetCommentOS() << ' ' << StrVal << '\n';
 2499       AP.OutStreamer->EmitIntValue(p[Chunk--], TrailingBytes);
 2502       AP.OutStreamer->EmitIntValue(p[Chunk], sizeof(uint64_t));
 2506       AP.OutStreamer->EmitIntValue(p[Chunk], sizeof(uint64_t));
 2509       AP.OutStreamer->EmitIntValue(p[Chunk], TrailingBytes);
 2514   AP.OutStreamer->EmitZeros(DL.getTypeAllocSize(ET) - DL.getTypeStoreSize(ET));
 2561     AP.OutStreamer->EmitIntValue(Val, 8);
 2573     AP.OutStreamer->EmitIntValue(ExtraBits, Size);
 2660       FinalGV, FinalSym, MV, Offset, AP.MMI, *AP.OutStreamer);
 2680     return AP.OutStreamer->EmitZeros(Size);
 2689         AP.OutStreamer->GetCommentOS() << format("0x%" PRIx64 "\n",
 2691       AP.OutStreamer->EmitIntValue(CI->getZExtValue(), Size);
 2703     AP.OutStreamer->EmitIntValue(0, Size);
 2745   AP.OutStreamer->EmitValue(ME, Size);
 2756     OutStreamer->EmitIntValue(0, 1);
 2802             OutStreamer->EmitSymbolAttribute(Sym, MCSA_Global);
 2880     AP.OutStreamer->AddComment("  in Loop: Header=BB" +
 2889   raw_ostream &OS = AP.OutStreamer->GetCommentOS();
 2935   OutStreamer->EmitCodePaddingBasicBlockStart(Context);
 2944       OutStreamer->AddComment("Block address taken");
 2950         OutStreamer->EmitLabel(Sym);
 2957         BB->printAsOperand(OutStreamer->GetCommentOS(),
 2959         OutStreamer->GetCommentOS() << '\n';
 2973       OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":",
 2978       OutStreamer->AddComment("Label of block must be emitted");
 2979     OutStreamer->EmitLabel(MBB.getSymbol());
 2986   OutStreamer->EmitCodePaddingBasicBlockEnd(Context);
 3007     OutStreamer->EmitSymbolAttribute(Sym, Attr);
 3124   auto PrevSection = OutStreamer->getCurrentSectionOnly();
 3160   OutStreamer->SwitchSection(InstMap);
 3161   OutStreamer->EmitLabel(SledsStart);
 3163     Sled.emit(WordSizeBytes, OutStreamer.get(), CurrentFnSym);
 3165   OutStreamer->EmitLabel(SledsEnd);
 3171   OutStreamer->SwitchSection(FnSledIndex);
 3172   OutStreamer->EmitCodeAlignment(2 * WordSizeBytes);
 3173   OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes, false);
 3174   OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes, false);
 3175   OutStreamer->SwitchSection(PrevSection);
 3193   return OutStreamer->getContext().getDwarfVersion();
 3197   OutStreamer->getContext().setDwarfVersion(Version);

   41     OutStreamer->AddComment(Desc);
   43   OutStreamer->EmitSLEB128IntValue(Value);
   48     OutStreamer->AddComment(Desc);
   50   OutStreamer->EmitULEB128IntValue(Value, PadTo);
   56   OutStreamer->emitAbsoluteSymbolDiffAsULEB128(Hi, Lo);
  111       OutStreamer->AddComment(Twine(Desc) + " Encoding = " +
  114       OutStreamer->AddComment(Twine("Encoding = ") + DecodeDWARFEncoding(Val));
  117   OutStreamer->EmitIntValue(Val, 1);
  145         TLOF.getTTypeGlobalReference(GV, Encoding, TM, MMI, *OutStreamer);
  146     OutStreamer->EmitValue(Exp, GetSizeOfEncodedValue(Encoding));
  148     OutStreamer->EmitIntValue(0, GetSizeOfEncodedValue(Encoding));
  156       OutStreamer->EmitCOFFSecRel32(Label, /*Offset=*/0);
  162       OutStreamer->EmitSymbolValue(Label, 4);
  202     OutStreamer->EmitIntValue(Value, GetSizeOfEncodedValue(Encoding));
  214     OutStreamer->EmitCFIDefCfaOffset(Inst.getOffset());
  217     OutStreamer->EmitCFIAdjustCfaOffset(Inst.getOffset());
  220     OutStreamer->EmitCFIDefCfa(Inst.getRegister(), Inst.getOffset());
  223     OutStreamer->EmitCFIDefCfaRegister(Inst.getRegister());
  226     OutStreamer->EmitCFIOffset(Inst.getRegister(), Inst.getOffset());
  229     OutStreamer->EmitCFIRegister(Inst.getRegister(), Inst.getRegister2());
  232     OutStreamer->EmitCFIWindowSave();
  235     OutStreamer->EmitCFINegateRAState();
  238     OutStreamer->EmitCFISameValue(Inst.getRegister());
  241     OutStreamer->EmitCFIGnuArgsSize(Inst.getOffset());
  244     OutStreamer->EmitCFIEscape(Inst.getValues());
  247     OutStreamer->EmitCFIRestore(Inst.getRegister());
  255     OutStreamer->AddComment("Abbrev [" + Twine(Die.getAbbrevNumber()) + "] 0x" +
  267       OutStreamer->AddComment(dwarf::AttributeString(Attr));
  269         OutStreamer->AddComment(
  282     OutStreamer->AddComment("End Of Children Mark");

  128       !OutStreamer->isIntegratedAssemblerRequired()) {
  130     OutStreamer->EmitRawText(Str);
  139           DiagInfo->SrcMgr, OutContext, *OutStreamer, *MAI, BufNum));
  142   OutStreamer->setUseAssemblerInfoForParsing(false);
  485     OutStreamer->emitRawComment(MAI->getInlineAsmStart());
  486     OutStreamer->emitRawComment(MAI->getInlineAsmEnd());
  492   OutStreamer->emitRawComment(MAI->getInlineAsmStart());
  566   OutStreamer->emitRawComment(MAI->getInlineAsmEnd());

   44     AP.OutStreamer->AddComment(Comment);
   48     AP.OutStreamer->AddComment(Comment);
   52     AP.OutStreamer->AddComment(Comment);

  151     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {

  173     AP->OutStreamer->SwitchSection(Section);
  381     Asm->OutStreamer->AddBlankLine();
  410     Asm->OutStreamer->EmitIntValue(Integer, SizeOf(Asm, Form));
  434               AP->OutStreamer->getContext().getDwarfFormat()};
  608     AP->OutStreamer->EmitBytes(S);
  638     AP->OutStreamer->EmitIntValue(Entry->getOffset(), SizeOf(AP, Form));
  654     AP->OutStreamer->EmitIntValue(Addr, SizeOf(AP, Form));
  677     switch (AP->OutStreamer->getContext().getDwarfFormat()) {

  300     Asm->OutStreamer->EmitLabel(PrevLabel);
  332     Asm->OutStreamer->EmitLabel(PrevLabel);

   50     Asm->OutStreamer->EmitCFIEndProc();
   79     TLOF.emitPersonalityValue(*Asm->OutStreamer, Asm->getDataLayout(), Sym);
  135       Asm->OutStreamer->EmitCFISections(false, true);
  139   Asm->OutStreamer->EmitCFIStartProc(/*IsSimple=*/false);
  157   Asm->OutStreamer->EmitCFIPersonality(Sym, PerEncoding);
  161     Asm->OutStreamer->EmitCFILsda(ESP(Asm), TLOF.getLSDAEncoding());

  105   unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
  107     return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", None, None, CUID);
  108   return Asm->OutStreamer->EmitDwarfFileDirective(
  349         Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
 1094     Asm->OutStreamer->EmitLabel(LabelBegin);

  344     : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
  417   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
  867   if (!Asm->OutStreamer->hasRawTextSupport() || SingleCU)
  868     Asm->OutStreamer->emitDwarfFile0Directive(
 1650       Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
 1755   Asm.OutStreamer->EmitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
 1795   if (Asm->OutStreamer->hasRawTextSupport())
 1797     Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
 1799     Asm->OutStreamer->getContext().setDwarfCompileUnitID(CU.getUniqueID());
 1803       *MF, Asm->OutStreamer->getContext().getDwarfCompileUnitID());
 1822   Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
 1902                      Asm->OutStreamer->getContext().getDwarfCompileUnitID(),
 1933   Asm->OutStreamer->SwitchSection(Section);
 2052     Asm->OutStreamer->SwitchSection(
 2057     Asm->OutStreamer->SwitchSection(
 2079   Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
 2084   Asm->OutStreamer->EmitLabel(BeginLabel);
 2086   Asm->OutStreamer->AddComment("DWARF Version");
 2089   Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
 2092   Asm->OutStreamer->AddComment("Compilation Unit Length");
 2100     Asm->OutStreamer->AddComment("DIE offset");
 2105       Asm->OutStreamer->AddComment(
 2111     Asm->OutStreamer->AddComment("External Name");
 2112     Asm->OutStreamer->EmitBytes(StringRef(Name, GI.getKeyLength() + 1));
 2115   Asm->OutStreamer->AddComment("End Mark");
 2117   Asm->OutStreamer->EmitLabel(EndLabel);
 2250   Asm->OutStreamer->AddComment("Loc expr size");
 2271   Asm->OutStreamer->AddComment("Length");
 2273   Asm->OutStreamer->EmitLabel(TableStart);
 2275   Asm->OutStreamer->AddComment("Version");
 2276   Asm->emitInt16(Asm->OutStreamer->getContext().getDwarfVersion());
 2278   Asm->OutStreamer->AddComment("Address size");
 2281   Asm->OutStreamer->AddComment("Segment selector size");
 2294   Asm->OutStreamer->AddComment("Offset entry count");
 2296   Asm->OutStreamer->EmitLabel(Holder.getRnglistsTableBaseSym());
 2318   Asm->OutStreamer->AddComment("Offset entry count");
 2320   Asm->OutStreamer->EmitLabel(DebugLocs.getSym());
 2338   Asm->OutStreamer->EmitLabel(Sym);
 2357         Asm->OutStreamer->EmitIntValue(-1, Size);
 2358         Asm->OutStreamer->AddComment("  base address");
 2359         Asm->OutStreamer->EmitSymbolValue(Base, Size);
 2366         Asm->OutStreamer->AddComment(StringifyEnum(BaseAddressx));
 2368         Asm->OutStreamer->AddComment("  base address index");
 2374       Asm->OutStreamer->EmitIntValue(-1, Size);
 2375       Asm->OutStreamer->EmitIntValue(0, Size);
 2386           Asm->OutStreamer->AddComment(StringifyEnum(OffsetPair));
 2388           Asm->OutStreamer->AddComment("  starting offset");
 2390           Asm->OutStreamer->AddComment("  ending offset");
 2397         Asm->OutStreamer->AddComment(StringifyEnum(StartxLength));
 2399         Asm->OutStreamer->AddComment("  start index");
 2401         Asm->OutStreamer->AddComment("  length");
 2404         Asm->OutStreamer->EmitSymbolValue(Begin, Size);
 2405         Asm->OutStreamer->EmitSymbolValue(End, Size);
 2412     Asm->OutStreamer->AddComment(StringifyEnum(EndOfList));
 2416     Asm->OutStreamer->EmitIntValue(0, Size);
 2417     Asm->OutStreamer->EmitIntValue(0, Size);
 2440     Asm->OutStreamer->SwitchSection(
 2444     Asm->OutStreamer->SwitchSection(
 2452     Asm->OutStreamer->EmitLabel(TableEnd);
 2457     Asm->OutStreamer->SwitchSection(
 2459     Asm->OutStreamer->EmitLabel(List.Label);
 2527       unsigned IA = A.Sym ? Asm->OutStreamer->GetSymbolOrder(A.Sym) : 0;
 2528       unsigned IB = B.Sym ? Asm->OutStreamer->GetSymbolOrder(B.Sym) : 0;
 2540     List.push_back(SymbolCU(nullptr, Asm->OutStreamer->endSection(Section)));
 2561   Asm->OutStreamer->SwitchSection(
 2603     Asm->OutStreamer->AddComment("Length of ARange Set");
 2605     Asm->OutStreamer->AddComment("DWARF Arange version number");
 2607     Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
 2609     Asm->OutStreamer->AddComment("Address Size (in bytes)");
 2611     Asm->OutStreamer->AddComment("Segment Size (in bytes)");
 2614     Asm->OutStreamer->emitFill(Padding, 0xff);
 2629         Asm->OutStreamer->EmitIntValue(Size, PtrSize);
 2633     Asm->OutStreamer->AddComment("ARange terminator");
 2634     Asm->OutStreamer->EmitIntValue(0, PtrSize);
 2635     Asm->OutStreamer->EmitIntValue(0, PtrSize);
 2657     Asm->OutStreamer->EmitLabel(TableEnd);
 2679     Asm->OutStreamer->SwitchSection(
 2683     Asm->OutStreamer->SwitchSection(
 2707   Asm->OutStreamer->SwitchSection(
 2730   Asm->OutStreamer->EmitBytes(Name);
 2734     Asm->OutStreamer->EmitBytes(Value);
 2759   Asm->OutStreamer->SwitchSection(
 2771       Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
 2775   Asm->OutStreamer->AddComment("End Of Macro List Mark");
 2827       *Asm->OutStreamer, MCDwarfLineTableParams(),
 3033   return Asm->OutStreamer->getContext().getDwarfVersion();

   51   Asm->OutStreamer->SwitchSection(S);
   56     Asm->OutStreamer->EmitLabel(EndLabel);

   60   Asm.OutStreamer->SwitchSection(Section);
   74     Asm.OutStreamer->EmitLabel(StartSym);
   83   Asm.OutStreamer->SwitchSection(StrSection);
  103       Asm.OutStreamer->EmitLabel(Entry->getValue().Symbol);
  106     Asm.OutStreamer->AddComment("string offset=" +
  108     Asm.OutStreamer->EmitBytes(
  122     Asm.OutStreamer->SwitchSection(OffsetSection);
  128         Asm.OutStreamer->EmitIntValue(Entry->getValue().Offset, size);

 1606   Asm->OutStreamer->AddComment("Length of Unit");
 1612     Asm->OutStreamer->EmitLabel(BeginLabel);
 1616   Asm->OutStreamer->AddComment("DWARF version number");
 1622     Asm->OutStreamer->AddComment("DWARF Unit Type");
 1624     Asm->OutStreamer->AddComment("Address Size (in bytes)");
 1631   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
 1640     Asm->OutStreamer->AddComment("Address Size (in bytes)");
 1649   Asm->OutStreamer->AddComment("Type Signature");
 1650   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
 1651   Asm->OutStreamer->AddComment("Type DIE Offset");
 1653   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,

  428     Asm->OutStreamer->SwitchSection(LSDASection);
  435   Asm->OutStreamer->EmitLabel(GCCETSym);
  436   Asm->OutStreamer->EmitLabel(Asm->getCurExceptionSym());
  451     Asm->OutStreamer->EmitLabel(TTBaseRefLabel);
  454   bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
  461   Asm->OutStreamer->EmitLabel(CstBeginLabel);
  472         Asm->OutStreamer->AddComment(">> Call Site " + Twine(idx) + " <<");
  473         Asm->OutStreamer->AddComment("  On exception at call site "+Twine(idx));
  482           Asm->OutStreamer->AddComment("  Action: cleanup");
  484           Asm->OutStreamer->AddComment("  Action: " +
  526         Asm->OutStreamer->AddComment(">> Call Site " + Twine(++Entry) + " <<");
  529         Asm->OutStreamer->AddComment(Twine("  Call between ") +
  537           Asm->OutStreamer->AddComment("    has no landing pad");
  541           Asm->OutStreamer->AddComment(Twine("    jumps to ") +
  552           Asm->OutStreamer->AddComment("  On action: cleanup");
  554           Asm->OutStreamer->AddComment("  On action: " +
  560   Asm->OutStreamer->EmitLabel(CstEndLabel);
  570       Asm->OutStreamer->AddComment(">> Action Record " + Twine(++Entry) + " <<");
  579         Asm->OutStreamer->AddComment("  Catch TypeInfo " +
  582         Asm->OutStreamer->AddComment("  Filter TypeInfo " +
  585         Asm->OutStreamer->AddComment("  Cleanup");
  595         Asm->OutStreamer->AddComment("  No further actions");
  598         Asm->OutStreamer->AddComment("  Continue to action "+Twine(NextAction));
  618   bool VerboseAsm = Asm->OutStreamer->isVerboseAsm();
  623     Asm->OutStreamer->AddComment(">> Catch TypeInfos <<");
  624     Asm->OutStreamer->AddBlankLine();
  631       Asm->OutStreamer->AddComment("TypeInfo " + Twine(Entry--));
  635   Asm->OutStreamer->EmitLabel(TTBaseLabel);
  639     Asm->OutStreamer->AddComment(">> Filter TypeInfos <<");
  640     Asm->OutStreamer->AddBlankLine();
  649         Asm->OutStreamer->AddComment("FilterInfo " + Twine(Entry));

   46   MCStreamer &OS = *AP.OutStreamer;

   69   AP.OutStreamer->EmitSymbolAttribute(Sym, MCSA_Global);
   70   AP.OutStreamer->EmitLabel(Sym);
   75   AP.OutStreamer->SwitchSection(AP.getObjFileLowering().getTextSection());
   78   AP.OutStreamer->SwitchSection(AP.getObjFileLowering().getDataSection());
  102   AP.OutStreamer->SwitchSection(AP.getObjFileLowering().getTextSection());
  105   AP.OutStreamer->SwitchSection(AP.getObjFileLowering().getDataSection());
  109   AP.OutStreamer->EmitIntValue(0, IntPtrSize);
  111   AP.OutStreamer->SwitchSection(AP.getObjFileLowering().getDataSection());
  153     AP.OutStreamer->AddComment("live roots for " +
  155     AP.OutStreamer->AddBlankLine();
  167       AP.OutStreamer->EmitSymbolValue(J->Label, IntPtrSize);

   30     Asm->OutStreamer->EmitLabel(ExceptionSym);
   61   Asm->OutStreamer->EmitLabel(LSDAEndLabel);
   62   MCContext &OutContext = Asm->OutStreamer->getContext();
   66   Asm->OutStreamer->emitELFSize(LSDALabel, SizeExp);

   52   auto &OS = *Asm->OutStreamer;

   52   auto &OS = *Asm->OutStreamer;
  115     Asm->OutStreamer->EmitWinCFIFuncletOrFuncEnd();
  144     Asm->OutStreamer->PushSection();
  147     MCSection *XData = Asm->OutStreamer->getAssociatedXDataSection(
  148         Asm->OutStreamer->getCurrentSectionOnly());
  149     Asm->OutStreamer->SwitchSection(XData);
  164     Asm->OutStreamer->PopSection();
  198     Asm->OutStreamer->BeginCOFFSymbolDef(Sym);
  199     Asm->OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);
  200     Asm->OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION
  202     Asm->OutStreamer->EndCOFFSymbolDef();
  210     Asm->OutStreamer->EmitLabel(Sym);
  215     CurrentFuncletTextSection = Asm->OutStreamer->getCurrentSectionOnly();
  216     Asm->OutStreamer->EmitWinCFIStartProc(Sym);
  235       Asm->OutStreamer->EmitWinEHHandler(PersHandlerSym, true, true);
  242     Asm->OutStreamer->SwitchSection(CurrentFuncletTextSection);
  243     Asm->OutStreamer->EmitWinCFIFuncletOrFuncEnd();
  264       MCSection *XData = Asm->OutStreamer->getAssociatedXDataSection(
  265           Asm->OutStreamer->getCurrentSectionOnly());
  266       Asm->OutStreamer->SwitchSection(XData);
  270     Asm->OutStreamer->EmitWinEHHandlerData();
  279       Asm->OutStreamer->EmitValue(create32bitRef(FuncInfoXData), 4);
  290     Asm->OutStreamer->SwitchSection(CurrentFuncletTextSection);
  291     Asm->OutStreamer->EmitWinCFIEndProc();
  550   auto &OS = *Asm->OutStreamer;
  569     Asm->OutStreamer->EmitAssignment(ParentFrameOffset, MCOffset);
  618   auto &OS = *Asm->OutStreamer;
  660   auto &OS = *Asm->OutStreamer;
  959   Asm->OutStreamer->EmitAssignment(ParentFrameOffset,
  967   MCStreamer &OS = *Asm->OutStreamer;
 1093   MCStreamer &OS = *Asm->OutStreamer;

   32   MCContext &OutContext = AP.OutStreamer->getContext();
   35   AP.OutStreamer->EmitLabel(FaultingLabel);
   53   MCContext &OutContext = AP.OutStreamer->getContext();
   54   MCStreamer &OS = *AP.OutStreamer;
   82   MCStreamer &OS = *AP.OutStreamer;

  301   MCContext &OutContext = AP.OutStreamer->getContext();
  303   AP.OutStreamer->EmitLabel(MILabel);
  558   MCContext &OutContext = AP.OutStreamer->getContext();
  559   MCStreamer &OS = *AP.OutStreamer;

  134       OutStreamer->BeginCOFFSymbolDef(CurrentFnSym);
  135       OutStreamer->EmitCOFFSymbolStorageClass(Scl);
  136       OutStreamer->EmitCOFFSymbolType(Type);
  137       OutStreamer->EndCOFFSymbolDef();
  222   OutStreamer->EmitCodeAlignment(4);
  224   OutStreamer->EmitLabel(CurSled);
  230   EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::B).addImm(8));
  233     EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::HINT).addImm(0));
  235   OutStreamer->EmitLabel(Target);
  258   EmitToStreamer(*OutStreamer,
  290     OutStreamer->SwitchSection(OutContext.getELFSection(
  295     OutStreamer->EmitSymbolAttribute(Sym, MCSA_ELF_TypeFunction);
  296     OutStreamer->EmitSymbolAttribute(Sym, MCSA_Weak);
  297     OutStreamer->EmitSymbolAttribute(Sym, MCSA_Hidden);
  298     OutStreamer->EmitLabel(Sym);
  300     OutStreamer->EmitInstruction(MCInstBuilder(AArch64::UBFMXri)
  306     OutStreamer->EmitInstruction(MCInstBuilder(AArch64::LDRBBroX)
  313     OutStreamer->EmitInstruction(
  321     OutStreamer->EmitInstruction(
  328     OutStreamer->EmitLabel(ReturnSym);
  329     OutStreamer->EmitInstruction(
  331     OutStreamer->EmitLabel(HandleMismatchOrPartialSym);
  334       OutStreamer->EmitInstruction(MCInstBuilder(AArch64::SUBSWri)
  341       OutStreamer->EmitInstruction(
  347       OutStreamer->EmitInstruction(
  355         OutStreamer->EmitInstruction(MCInstBuilder(AArch64::ADDXri)
  361       OutStreamer->EmitInstruction(MCInstBuilder(AArch64::SUBSWrs)
  367       OutStreamer->EmitInstruction(
  373       OutStreamer->EmitInstruction(
  379       OutStreamer->EmitInstruction(MCInstBuilder(AArch64::LDRBBui)
  384       OutStreamer->EmitInstruction(
  391       OutStreamer->EmitInstruction(
  397       OutStreamer->EmitLabel(HandleMismatchSym);
  400     OutStreamer->EmitInstruction(MCInstBuilder(AArch64::STPXpre)
  407     OutStreamer->EmitInstruction(MCInstBuilder(AArch64::STPXi)
  415       OutStreamer->EmitInstruction(MCInstBuilder(AArch64::ORRXrs)
  421     OutStreamer->EmitInstruction(MCInstBuilder(AArch64::MOVZXi)
  430     OutStreamer->EmitInstruction(
  437     OutStreamer->EmitInstruction(
  445     OutStreamer->EmitInstruction(
  460     OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
  475     OutStreamer->EmitLOHDirective(D.getKind(), MCArgs);
  703       OutStreamer->SwitchSection(ReadOnlySec);
  715     OutStreamer->EmitLabel(GetJTISymbol(JTI));
  743   OutStreamer->EmitValue(Value, Size);
  877     EmitToStreamer(*OutStreamer, MOVI);
  898     EmitToStreamer(*OutStreamer, FMov);
  908   if (emitPseudoExpansionLowering(*OutStreamer, MI))
  916     OutStreamer->EmitLabel(LOHLabel);
  920     static_cast<AArch64TargetStreamer *>(OutStreamer->getTargetStreamer());
  942       EmitToStreamer(*OutStreamer, MovZ);
  950       EmitToStreamer(*OutStreamer, MovK);
  962       EmitToStreamer(*OutStreamer, TmpInst);
  968     if (isVerbose() && OutStreamer->hasRawTextSupport()) {
  972       OutStreamer->EmitRawText(StringRef(OS.str()));
  985       OutStreamer->EmitCFIBKeyFrame();
  999     EmitToStreamer(*OutStreamer, TmpInst);
 1008     EmitToStreamer(*OutStreamer, TmpInst);
 1032     EmitToStreamer(*OutStreamer, Adrp);
 1040     EmitToStreamer(*OutStreamer, Ldr);
 1048     EmitToStreamer(*OutStreamer, Add);
 1055     EmitToStreamer(*OutStreamer, TLSDescCall);
 1060     EmitToStreamer(*OutStreamer, Blr);
 1073     EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::LDRSWroX)
 1079     EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::ADDXrs)
 1088     LowerJumpTableDestSmall(*OutStreamer, *MI);
 1098     return LowerSTACKMAP(*OutStreamer, SM, *MI);
 1101     return LowerPATCHPOINT(*OutStreamer, SM, *MI);
 1218   EmitToStreamer(*OutStreamer, TmpInst);

  119   if (!OutStreamer)
  121   return static_cast<AMDGPUTargetStreamer*>(OutStreamer->getTargetStreamer());
  335     OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
  351   OutStreamer->emitRawComment(" codeLenInByte = " + Twine(CodeSize), false);
  352   OutStreamer->emitRawComment(" NumSgprs: " + Twine(NumSGPR), false);
  353   OutStreamer->emitRawComment(" NumVgprs: " + Twine(NumVGPR), false);
  355     OutStreamer->emitRawComment(" NumAgprs: " + Twine(*NumAGPR), false);
  356     OutStreamer->emitRawComment(" TotalNumVgprs: " + Twine(TotalNumVGPR),
  359   OutStreamer->emitRawComment(" ScratchSize: " + Twine(ScratchSize), false);
  360   OutStreamer->emitRawComment(" MemoryBound: " + Twine(MFI->isMemoryBound()),
  437     OutStreamer->SwitchSection(ConfigSection);
  460     bool SaveFlag = OutStreamer->getUseAssemblerInfoForParsing();
  461     OutStreamer->setUseAssemblerInfoForParsing(true);
  462     MCAssembler *Assembler = OutStreamer->getAssemblerPtr();
  463     OutStreamer->setUseAssemblerInfoForParsing(SaveFlag);
  477     OutStreamer->SwitchSection(CommentSection);
  480       OutStreamer->emitRawComment(" Function info:", false);
  492     OutStreamer->emitRawComment(" Kernel info:", false);
  502     OutStreamer->emitRawComment(
  504     OutStreamer->emitRawComment(
  506     OutStreamer->emitRawComment(
  510     OutStreamer->emitRawComment(
  512     OutStreamer->emitRawComment(
  515     OutStreamer->emitRawComment(
  518     OutStreamer->emitRawComment(
  522     OutStreamer->emitRawComment(
  526     OutStreamer->emitRawComment(
  529     OutStreamer->emitRawComment(
  532     OutStreamer->emitRawComment(
  535     OutStreamer->emitRawComment(
  538     OutStreamer->emitRawComment(
  541     OutStreamer->emitRawComment(
  544     OutStreamer->emitRawComment(
  552     OutStreamer->SwitchSection(
  562       OutStreamer->EmitBytes(StringRef(DisasmLines[i]));
  563       OutStreamer->EmitBytes(StringRef(Comment));
 1128     OutStreamer->EmitIntValue(R_00B848_COMPUTE_PGM_RSRC1, 4);
 1130     OutStreamer->EmitIntValue(CurrentProgramInfo.ComputePGMRSrc1, 4);
 1132     OutStreamer->EmitIntValue(R_00B84C_COMPUTE_PGM_RSRC2, 4);
 1133     OutStreamer->EmitIntValue(CurrentProgramInfo.ComputePGMRSrc2, 4);
 1135     OutStreamer->EmitIntValue(R_00B860_COMPUTE_TMPRING_SIZE, 4);
 1136     OutStreamer->EmitIntValue(S_00B860_WAVESIZE(CurrentProgramInfo.ScratchBlocks), 4);
 1141     OutStreamer->EmitIntValue(RsrcReg, 4);
 1142     OutStreamer->EmitIntValue(S_00B028_VGPRS(CurrentProgramInfo.VGPRBlocks) |
 1144     OutStreamer->EmitIntValue(R_0286E8_SPI_TMPRING_SIZE, 4);
 1145     OutStreamer->EmitIntValue(
 1150     OutStreamer->EmitIntValue(R_00B02C_SPI_SHADER_PGM_RSRC2_PS, 4);
 1151     OutStreamer->EmitIntValue(S_00B02C_EXTRA_LDS_SIZE(CurrentProgramInfo.LDSBlocks), 4);
 1152     OutStreamer->EmitIntValue(R_0286CC_SPI_PS_INPUT_ENA, 4);
 1153     OutStreamer->EmitIntValue(MFI->getPSInputEnable(), 4);
 1154     OutStreamer->EmitIntValue(R_0286D0_SPI_PS_INPUT_ADDR, 4);
 1155     OutStreamer->EmitIntValue(MFI->getPSInputAddr(), 4);
 1158   OutStreamer->EmitIntValue(R_SPILLED_SGPRS, 4);
 1159   OutStreamer->EmitIntValue(MFI->getNumSpilledSGPRs(), 4);
 1160   OutStreamer->EmitIntValue(R_SPILLED_VGPRS, 4);
 1161   OutStreamer->EmitIntValue(MFI->getNumSpilledVGPRs(), 4);

  258   if (emitPseudoExpansionLowering(*OutStreamer, MI))
  291         OutStreamer->emitRawComment(Twine(" mask branch ") + BBStr);
  299         OutStreamer->emitRawComment(" return to shader part epilog");
  305         OutStreamer->emitRawComment(" wave barrier");
  311         OutStreamer->emitRawComment(" divergent unreachable");
  317     EmitToStreamer(*OutStreamer, TmpInst);
  405     EmitToStreamer(*OutStreamer, TmpInst);

   91   OutStreamer->EmitIntValue(RsrcReg, 4);
   92   OutStreamer->EmitIntValue(S_NUM_GPRS(MaxGPR + 1) |
   94   OutStreamer->EmitIntValue(R_02880C_DB_SHADER_CONTROL, 4);
   95   OutStreamer->EmitIntValue(S_02880C_KILL_ENABLE(killPixel), 4);
   98     OutStreamer->EmitIntValue(R_0288E8_SQ_LDS_ALLOC, 4);
   99     OutStreamer->EmitIntValue(alignTo(MFI->getLDSSize(), 4) >> 2, 4);
  114   OutStreamer->SwitchSection(ConfigSection);
  123     OutStreamer->SwitchSection(CommentSection);
  126     OutStreamer->emitRawComment(

   61   EmitToStreamer(*OutStreamer, TmpInst);

   66   OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
   71     OutStreamer->EmitAssemblerFlag(MCAF_Code16);
   72     OutStreamer->EmitThumbFunc(CurrentFnSym);
   74     OutStreamer->EmitAssemblerFlag(MCAF_Code32);
   76   OutStreamer->EmitLabel(CurrentFnSym);
   93   OutStreamer->EmitValue(E, Size);
  154     OutStreamer->BeginCOFFSymbolDef(CurrentFnSym);
  155     OutStreamer->EmitCOFFSymbolStorageClass(Scl);
  156     OutStreamer->EmitCOFFSymbolType(Type);
  157     OutStreamer->EndCOFFSymbolDef();
  170     OutStreamer->EmitAssemblerFlag(MCAF_Code16);
  173       OutStreamer->EmitLabel(TIP.second);
  174       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tBX)
  470     OutStreamer->EmitAssemblerFlag(WasThumb ? MCAF_Code16 : MCAF_Code32);
  477   OutStreamer->EmitAssemblerFlag(MCAF_SyntaxUnified);
  487     OutStreamer->EmitAssemblerFlag(MCAF_Code16);
  528       OutStreamer->SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
  532         emitNonLazySymbolPointer(*OutStreamer, Stub.first, Stub.second);
  535       OutStreamer->AddBlankLine();
  541       OutStreamer->SwitchSection(TLOFMacho.getThreadLocalPointerSection());
  545         emitNonLazySymbolPointer(*OutStreamer, Stub.first, Stub.second);
  548       OutStreamer->AddBlankLine();
  556     OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
  560   MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
  589   MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
  879         OutStreamer->EmitLabel(GVSym);
  928       OutStreamer->EmitLabel(DotSym);
  934   OutStreamer->EmitValue(Expr, Size);
  947   OutStreamer->EmitLabel(JTISymbol);
  950   OutStreamer->EmitDataRegion(MCDR_DataRegionJT32);
  977     OutStreamer->EmitValue(Expr, 4);
  980   OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
  993   OutStreamer->EmitLabel(JTISymbol);
 1004     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::t2B)
 1021   OutStreamer->EmitLabel(JTISymbol);
 1029   OutStreamer->EmitDataRegion(OffsetWidth == 1 ? MCDR_DataRegionJT8
 1053     OutStreamer->EmitValue(Expr, OffsetWidth);
 1058   OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
 1068   MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
 1240   MCTargetStreamer &TS = *OutStreamer->getTargetStreamer();
 1249     OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
 1259   if (emitPseudoExpansionLowering(*OutStreamer, MI))
 1275     EmitToStreamer(*OutStreamer, MCInstBuilder(MI->getOpcode() ==
 1291     EmitToStreamer(*OutStreamer, MCInstBuilder(MI->getOpcode() ==
 1305     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::MOVr)
 1315     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::BX)
 1344     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tBL)
 1351     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::MOVr)
 1360     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::MOVr)
 1371     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::MOVr)
 1385     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::Bcc)
 1420     EmitToStreamer(*OutStreamer, TmpInst);
 1452     EmitToStreamer(*OutStreamer, TmpInst);
 1503     EmitToStreamer(*OutStreamer, MCInst);
 1510     OutStreamer->EmitLabel(getBFLabel(DL.getPrivateGlobalPrefix(),
 1522     OutStreamer->EmitLabel(getPICLabel(DL.getPrivateGlobalPrefix(),
 1527     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDhirr)
 1543     OutStreamer->EmitLabel(getPICLabel(DL.getPrivateGlobalPrefix(),
 1548     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::ADDrr)
 1574     OutStreamer->EmitLabel(getPICLabel(DL.getPrivateGlobalPrefix(),
 1592     EmitToStreamer(*OutStreamer, MCInstBuilder(Opcode)
 1617       OutStreamer->EmitDataRegion(MCDR_DataRegion);
 1621     OutStreamer->EmitLabel(GetCPISymbol(LabelId));
 1641     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tMOVr)
 1653     OutStreamer->EmitLabel(GetCPISymbol(MI->getOperand(3).getImm()));
 1654     EmitToStreamer(*OutStreamer, MCInstBuilder(Opc)
 1672       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLSLri)
 1695       OutStreamer->EmitCodeAlignment(4);
 1696       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDhirr)
 1705       EmitToStreamer(*OutStreamer, MCInstBuilder(Opc)
 1719       EmitToStreamer(*OutStreamer, MCInstBuilder(Opc)
 1728     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLSLri)
 1737     OutStreamer->EmitLabel(GetCPISymbol(MI->getOperand(3).getImm()));
 1738     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDhirr)
 1762     EmitToStreamer(*OutStreamer, TmpInst);
 1775     EmitToStreamer(*OutStreamer, TmpInst);
 1789     EmitToStreamer(*OutStreamer, TmpInst);
 1794     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::ADDrr)
 1806     OutStreamer->EmitZeros(MI->getOperand(1).getImm());
 1813       OutStreamer->AddComment("trap");
 1821     OutStreamer->AddComment("trap");
 1830       OutStreamer->AddComment("trap");
 1850     OutStreamer->AddComment("eh_setjmp begin");
 1851     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tMOVr)
 1858     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDi3)
 1868     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tSTRi)
 1878     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tMOVi8)
 1887     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tB)
 1892     OutStreamer->AddComment("eh_setjmp end");
 1893     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tMOVi8)
 1901     OutStreamer->EmitLabel(Label);
 1916     OutStreamer->AddComment("eh_setjmp begin");
 1917     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::ADDri)
 1927     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::STRi12)
 1935     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::MOVi)
 1944     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::ADDri)
 1954     OutStreamer->AddComment("eh_setjmp end");
 1955     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::MOVi)
 1972     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::LDRi12)
 1980     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::LDRi12)
 1990       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::LDRi12)
 2000       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::LDRi12)
 2007       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::LDRi12)
 2017     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::BX)
 2033     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLDRi)
 2043     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tMOVr)
 2050     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLDRi)
 2060       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLDRi)
 2070       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLDRi)
 2077       EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tLDRi)
 2086     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tBX)
 2100     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::t2LDRi12)
 2107     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::t2LDRi12)
 2114     EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::t2LDRi12)
 2137   EmitToStreamer(*OutStreamer, TmpInst);

  197   OutStreamer->EmitCodeAlignment(4);
  199   OutStreamer->EmitLabel(CurSled);
  207   EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::Bcc).addImm(20)
  213     OutStreamer->EmitInstruction(Noop, getSubtargetInfo());
  215   OutStreamer->EmitLabel(Target);

  176   EmitToStreamer(*OutStreamer, I);

  147   EmitToStreamer(*OutStreamer, TmpInst);

  382     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), SkipInstruction(false),

  268   const MCRegisterInfo *RI = OutStreamer->getContext().getRegisterInfo();
  327     if (!OutStreamer->hasRawTextSupport()) {
  329       MCSectionSubPair Current = OutStreamer->getCurrentSection();
  331       MCSymbol *Sym = smallData(*this, MI, *OutStreamer, Imm, 8);
  333       OutStreamer->SwitchSection(Current.first, Current.second);
  345     if (!OutStreamer->hasRawTextSupport()) {
  347       MCSectionSubPair Current = OutStreamer->getCurrentSection();
  348       MCSymbol *Sym = smallData(*this, MI, *OutStreamer, Imm, 4);
  349       OutStreamer->SwitchSection(Current.first, Current.second);
  765   MCContext &Ctx = OutStreamer->getContext();
  771   OutStreamer->EmitInstruction(MCB, getSubtargetInfo());

  158   OutStreamer->EmitInstruction(MCInstBuilder(Lanai::ADD_I_LO)
  166   OutStreamer->EmitInstruction(MCInstBuilder(Lanai::SW_RI)
  178     OutStreamer->EmitInstruction(TmpInst, STI);
  180     OutStreamer->EmitInstruction(MCInstBuilder(Lanai::ADD_R)
  194   OutStreamer->EmitInstruction(TmpInst, STI);

  156   EmitToStreamer(*OutStreamer, TmpInst);
  160   MCSection *Cur = OutStreamer->getCurrentSectionOnly();
  166   MCSection *IV = OutStreamer->getContext().getELFSection(
  169   OutStreamer->SwitchSection(IV);
  172   OutStreamer->EmitSymbolValue(FunctionSymbol, TM.getProgramPointerSize());
  173   OutStreamer->SwitchSection(Cur);

   75   return static_cast<MipsTargetStreamer &>(*OutStreamer->getTargetStreamer());
  205     OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
  221       OutStreamer->EmitDataRegion(MCDR_DataRegion);
  225     OutStreamer->EmitLabel(GetCPISymbol(LabelId));
  249     emitDirectiveRelocJalr(*MI, OutContext, TM, *OutStreamer, *Subtarget);
  257     if (emitPseudoExpansionLowering(*OutStreamer, &*I))
  266       emitPseudoIndirectBranch(*OutStreamer, &*I);
  283     EmitToStreamer(*OutStreamer, TmpInst0);
  418   OutStreamer->EmitLabel(CurrentFnSym);
  461   OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
  800   OutStreamer->SwitchSection(
  827   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
  843   OutStreamer->AddBlankLine();
  848   OutStreamer->AddBlankLine();
  857   OutStreamer->EmitInstruction(I, STI);
  865   OutStreamer->EmitInstruction(I, STI);
  885   OutStreamer->EmitInstruction(I, STI);
  896   OutStreamer->EmitInstruction(I, STI);
  987   OutStreamer->EmitSymbolAttribute(MSymbol, MCSA_Global);
 1035   OutStreamer->AddComment("\t# Stub function to call " + Twine(RetType) + " " +
 1040   OutStreamer->PushSection();
 1047   OutStreamer->SwitchSection(M, nullptr);
 1051   OutStreamer->EmitValueToAlignment(4);
 1070   OutStreamer->EmitSymbolAttribute(MType, MCSA_ELF_TypeFunction);
 1071   OutStreamer->EmitLabel(Stub);
 1110   OutStreamer->EmitLabel(Tmp);
 1114   OutStreamer->emitELFSize(Stub, T_min_E);
 1116   OutStreamer->PopSection();
 1132   OutStreamer->SwitchSection(OutContext.getObjectFileInfo()->getTextSection());
 1200   OutStreamer->EmitCodeAlignment(4);
 1202   OutStreamer->EmitLabel(CurSled);
 1209   EmitToStreamer(*OutStreamer, MCInstBuilder(Mips::BEQ)
 1215     EmitToStreamer(*OutStreamer, MCInstBuilder(Mips::SLL)
 1220   OutStreamer->EmitLabel(Target);
 1223     EmitToStreamer(*OutStreamer,
 1257         OutStreamer->EmitDTPRel32Value(MipsExpr->getSubExpr());
 1260         OutStreamer->EmitDTPRel64Value(MipsExpr->getSubExpr());

  147   EmitToStreamer(*OutStreamer, Inst);
  440     OutStreamer->EmitRawText(StringRef("\t.pragma \"nounroll\";\n"));
  470   OutStreamer->EmitRawText(O.str());
  474   OutStreamer->EmitRawText(StringRef("{\n"));
  488   OutStreamer->EmitRawText(StringRef("}\n"));
  496   OutStreamer->EmitRawText(O.str());
  512     OutStreamer->AddComment(Twine("implicit-def: ") +
  516     OutStreamer->AddComment(Twine("implicit-def: ") +
  519   OutStreamer->AddBlankLine();
  795   OutStreamer->EmitRawText(OS1.str());
  799     OutStreamer->AddComment("Start of file scope inline assembly");
  800     OutStreamer->AddBlankLine();
  801     OutStreamer->EmitRawText(StringRef(M.getModuleInlineAsm()));
  802     OutStreamer->AddBlankLine();
  803     OutStreamer->AddComment("End of file scope inline assembly");
  804     OutStreamer->AddBlankLine();
  841   OutStreamer->EmitRawText(OS2.str());
  929     static_cast<NVPTXTargetStreamer *>(OutStreamer->getTargetStreamer())
  932     OutStreamer->EmitRawText("\t.section\t.debug_loc\t{\t}");
  936   static_cast<NVPTXTargetStreamer *>(OutStreamer->getTargetStreamer())
 1687   OutStreamer->EmitRawText(O.str());

  374     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
  394       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI8)
  398       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::RLDIC)
  403       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ORIS8)
  408       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ORI8)
  415       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::STD)
  427         EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
  432         EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
  439       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR8)
  442       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTRL8));
  446       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
  457     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL8_NOP)
  472     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
  508   EmitToStreamer(*OutStreamer,
  597     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL).addExpr(OffsExpr));
  609     EmitToStreamer(*OutStreamer,
  616     OutStreamer->EmitLabel(PICBase);
  641           *OutStreamer,
  646           *OutStreamer,
  667       EmitToStreamer(*OutStreamer, TmpInst);
  673       EmitToStreamer(*OutStreamer, TmpInst);
  700       EmitToStreamer(*OutStreamer, TmpInst);
  719       EmitToStreamer(*OutStreamer, TmpInst);
  729     EmitToStreamer(*OutStreamer, TmpInst);
  759     EmitToStreamer(*OutStreamer, TmpInst);
  789     EmitToStreamer(*OutStreamer, TmpInst);
  819     EmitToStreamer(*OutStreamer, TmpInst);
  859     EmitToStreamer(*OutStreamer, TmpInst);
  894     EmitToStreamer(*OutStreamer, TmpInst);
  917     EmitToStreamer(*OutStreamer, TmpInst);
  930     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
  951     EmitToStreamer(*OutStreamer, TmpInst);
  960     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL)
  968     OutStreamer->EmitLabel(GOTRef);
  969     OutStreamer->EmitValue(OffsExpr, 4);
  970     OutStreamer->EmitLabel(NextInstr);
  971     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR)
  973     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LWZ)
  977     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD4)
  990     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI)
  993     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
 1009     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
 1028     EmitToStreamer(*OutStreamer,
 1054     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
 1073     EmitToStreamer(*OutStreamer,
 1102         *OutStreamer,
 1121     EmitToStreamer(*OutStreamer,
 1135       OutStreamer->AddComment(PPCInstPrinter::
 1137       EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
 1151       OutStreamer->AddComment(PPCInstPrinter::
 1153       EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
 1181   EmitToStreamer(*OutStreamer, TmpInst);
 1205     OutStreamer->EmitLabel(BeginOfSled);
 1206     EmitToStreamer(*OutStreamer,
 1209     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
 1211         *OutStreamer,
 1213     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
 1214     EmitToStreamer(*OutStreamer,
 1219     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
 1220     OutStreamer->EmitLabel(EndOfSled);
 1244       EmitToStreamer(*OutStreamer, RetInst);
 1270           *OutStreamer,
 1291     OutStreamer->EmitCodeAlignment(8);
 1293     OutStreamer->EmitLabel(BeginOfSled);
 1294     EmitToStreamer(*OutStreamer, RetInst);
 1295     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
 1297         *OutStreamer,
 1299     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
 1300     EmitToStreamer(*OutStreamer,
 1305     EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
 1306     EmitToStreamer(*OutStreamer, RetInst);
 1308       OutStreamer->EmitLabel(FallthroughLabel);
 1325       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
 1338   OutStreamer->SwitchSection(OutContext.getELFSection(
 1344   OutStreamer->EmitLabel(CurrentPos);
 1353   OutStreamer->EmitAssignment(TOCSym, tocExpr);
 1355   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
 1370       OutStreamer->EmitLabel(RelocSymbol);
 1378       OutStreamer->EmitValue(OffsExpr, 4);
 1379       OutStreamer->EmitLabel(CurrentFnSym);
 1403       OutStreamer->EmitLabel(PPCFI->getTOCOffsetSymbol());
 1404       OutStreamer->EmitValue(TOCDeltaExpr, 8);
 1410   MCSectionSubPair Current = OutStreamer->getCurrentSection();
 1411   MCSectionELF *Section = OutStreamer->getContext().getELFSection(
 1413   OutStreamer->SwitchSection(Section);
 1414   OutStreamer->EmitLabel(CurrentFnSym);
 1415   OutStreamer->EmitValueToAlignment(8);
 1419   OutStreamer->EmitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
 1423   OutStreamer->EmitValue(
 1427   OutStreamer->EmitIntValue(0, 8 /* size */);
 1428   OutStreamer->SwitchSection(Current.first, Current.second);
 1437       static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
 1443       Section = OutStreamer->getContext().getELFSection(
 1446           Section = OutStreamer->getContext().getELFSection(
 1448     OutStreamer->SwitchSection(Section);
 1454       OutStreamer->EmitLabel(TOCEntryLabel);
 1458         OutStreamer->EmitValueToAlignment(4);
 1459         OutStreamer->EmitSymbolValue(TOCEntryTarget, 4);
 1509     OutStreamer->EmitLabel(GlobalEntryLabel);
 1521       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
 1528       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
 1538       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
 1542       EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD8)
 1549     OutStreamer->EmitLabel(LocalEntryLabel);
 1557       static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
 1576     OutStreamer->EmitIntValue(0, 4/*size*/);
 1577     OutStreamer->EmitIntValue(0, 8/*size*/);
 1629       *static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
 1636   OutStreamer->SwitchSection(TLOFMacho.getTextCoalSection());
 1638     OutStreamer->SwitchSection(
 1644     OutStreamer->SwitchSection(
 1650   OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
 1684       OutStreamer->SwitchSection(TLOFMacho.getNonLazySymbolPointerSection());
 1689         OutStreamer->EmitLabel(Stubs[i].first);
 1692         OutStreamer->EmitSymbolAttribute(MCSym.getPointer(),
 1697           OutStreamer->EmitIntValue(0, isPPC64 ? 8 : 4 /*size*/);
 1706           OutStreamer->EmitValue(
 1712       OutStreamer->AddBlankLine();
 1721   OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
 1730   MCSectionXCOFF *FnDescSec = OutStreamer->getContext().getXCOFFSection(
 1757   OutStreamer->SwitchSection(CSect);
 1774       OutStreamer->EmitXCOFFLocalCommonSymbol(GVSym, Size, Align);
 1776       OutStreamer->EmitCommonSymbol(GVSym, Size, Align);
 1783   OutStreamer->EmitLabel(EmittedInitSym);
 1791   MCSectionSubPair Current = OutStreamer->getCurrentSection();
 1793   OutStreamer->SwitchSection(
 1795   OutStreamer->EmitLabel(CurrentFnDescSym);
 1797   OutStreamer->EmitValue(MCSymbolRefExpr::create(CurrentFnSym, OutContext),
 1801   OutStreamer->EmitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
 1804   OutStreamer->EmitIntValue(0, PointerSize);
 1806   OutStreamer->SwitchSection(Current.first, Current.second);
 1817   MCSectionXCOFF *TOCBaseSection = OutStreamer->getContext().getXCOFFSection(
 1822   OutStreamer->SwitchSection(TOCBaseSection);

   66                           OutStreamer->getContext());
   67   AsmPrinter::EmitToStreamer(*OutStreamer, Res ? CInst : Inst);
   76   if (emitPseudoExpansionLowering(*OutStreamer, MI))
   81   EmitToStreamer(*OutStreamer, TmpInst);

   42           *OutStreamer->getTargetStreamer());
  188       EmitHiLo(*OutStreamer, GOTLabel,
  193       EmitHiLo(*OutStreamer, GOTLabel,
  198       EmitSHL(*OutStreamer, MCRegOP, imm, MCRegOP, STI);
  201       EmitOR(*OutStreamer, MCRegOP, lo, MCRegOP, STI);
  205       EmitHiLo(*OutStreamer, GOTLabel,
  210       EmitSHL(*OutStreamer, MCRegOP, imm, MCRegOP, STI);
  213       EmitHiLo(*OutStreamer, GOTLabel,
  216       EmitADD(*OutStreamer, MCRegOP, RegO7, MCRegOP, STI);
  236   OutStreamer->EmitLabel(StartLabel);
  238   EmitCall(*OutStreamer, Callee, STI);
  239   OutStreamer->EmitLabel(SethiLabel);
  243   EmitSETHI(*OutStreamer, hiImm, MCRegOP, STI);
  244   OutStreamer->EmitLabel(EndLabel);
  248   EmitOR(*OutStreamer, MCRegOP, loImm, MCRegOP, STI);
  249   EmitADD(*OutStreamer, MCRegOP, RegO7, MCRegOP, STI);
  269     EmitToStreamer(*OutStreamer, TmpInst);

  471     OutStreamer->emitRawComment("MEMBARRIER");
  480     OutStreamer->EmitLabel(DotSym);
  493     OutStreamer->EmitLabel(DotSym);
  520   EmitToStreamer(*OutStreamer, LoweredMI);
  558     EmitNop(Ctx, *OutStreamer, 6, getSubtargetInfo());
  565   OutStreamer->EmitInstruction(MCInstBuilder(SystemZ::BRASL)
  596     ShadowBytes += EmitNop(OutContext, *OutStreamer, NumNOPBytes - ShadowBytes,
  621       EmitToStreamer(*OutStreamer, MCInstBuilder(SystemZ::LLILF)
  626         EmitToStreamer(*OutStreamer, MCInstBuilder(SystemZ::IIHF)
  632       EmitToStreamer(*OutStreamer, MCInstBuilder(SystemZ::BASR)
  639     EmitToStreamer(*OutStreamer, MCInstBuilder(SystemZ::BRASL)
  652     EncodedBytes += EmitNop(OutContext, *OutStreamer, NumBytes - EncodedBytes,
  679   OutStreamer->EmitValue(Expr, Size);

   80   MCTargetStreamer *TS = OutStreamer->getTargetStreamer();
  139         OutStreamer->emitELFSize(getSymbol(&G),
  155       OutStreamer->PushSection();
  159       OutStreamer->SwitchSection(MySection);
  160       OutStreamer->EmitBytes(Contents->getString());
  161       OutStreamer->PopSection();
  199     OutStreamer->PushSection();
  200     OutStreamer->SwitchSection(Producers);
  201     OutStreamer->EmitULEB128IntValue(FieldCount);
  206       OutStreamer->EmitULEB128IntValue(strlen(Producers.first));
  207       OutStreamer->EmitBytes(Producers.first);
  208       OutStreamer->EmitULEB128IntValue(Producers.second->size());
  210         OutStreamer->EmitULEB128IntValue(Producer.first.size());
  211         OutStreamer->EmitBytes(Producer.first);
  212         OutStreamer->EmitULEB128IntValue(Producer.second.size());
  213         OutStreamer->EmitBytes(Producer.second);
  216     OutStreamer->PopSection();
  257   OutStreamer->PushSection();
  258   OutStreamer->SwitchSection(FeaturesSection);
  260   OutStreamer->EmitULEB128IntValue(EmittedFeatures.size());
  262     OutStreamer->EmitIntValue(F.Prefix, 1);
  263     OutStreamer->EmitULEB128IntValue(F.Name.size());
  264     OutStreamer->EmitBytes(F.Name);
  267   OutStreamer->PopSection();
  339       OutStreamer->AddComment("fallthrough-return");
  340       OutStreamer->AddBlankLine();
  360     EmitToStreamer(*OutStreamer, TmpInst);

   70     OutStreamer->BeginCOFFSymbolDef(CurrentFnSym);
   71     OutStreamer->EmitCOFFSymbolStorageClass(
   73     OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION
   75     OutStreamer->EndCOFFSymbolDef();
   93         static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
  103             static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
  571       MCSection *Cur = OutStreamer->getCurrentSectionOnly();
  574       OutStreamer->SwitchSection(Nt);
  579       OutStreamer->EmitIntValue(4, 4 /*size*/); // data size for "GNU\0"
  580       OutStreamer->EmitIntValue(8 + WordSize, 4 /*size*/); // Elf_Prop size
  581       OutStreamer->EmitIntValue(ELF::NT_GNU_PROPERTY_TYPE_0, 4 /*size*/);
  582       OutStreamer->EmitBytes(StringRef("GNU", 4)); // note name
  585       OutStreamer->EmitIntValue(ELF::GNU_PROPERTY_X86_FEATURE_1_AND, 4);
  586       OutStreamer->EmitIntValue(4, 4);               // data size
  587       OutStreamer->EmitIntValue(FeatureFlagsAnd, 4); // data
  590       OutStreamer->endSection(Nt);
  591       OutStreamer->SwitchSection(Cur);
  596     OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
  602     OutStreamer->BeginCOFFSymbolDef(S);
  603     OutStreamer->EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);
  604     OutStreamer->EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_NULL);
  605     OutStreamer->EndCOFFSymbolDef();
  620     OutStreamer->EmitSymbolAttribute(S, MCSA_Global);
  621     OutStreamer->EmitAssignment(
  624   OutStreamer->EmitSyntaxDirective();
  630     OutStreamer->EmitAssemblerFlag(MCAF_Code16);
  685     emitNonLazyStubs(MMI, *OutStreamer);
  696     OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
  715       OutStreamer->EmitSymbolAttribute(S, MCSA_Global);

  134     SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());

  103   OutStreamer->EmitInstruction(Inst, getSubtargetInfo());
  275       AsmPrinter.OutStreamer->EmitAssignment(Label, Expr);
  886   MCContext &Ctx = OutStreamer->getContext();
 1103     EmitNops(*OutStreamer, PatchBytes, Subtarget->is64Bit(),
 1146     OutStreamer->EmitInstruction(CallInst, getSubtargetInfo());
 1181   OutStreamer->AddComment("on-fault: " + HandlerLabel->getName());
 1182   OutStreamer->EmitInstruction(MI, getSubtargetInfo());
 1188   MCContext &Ctx = OutStreamer->getContext();
 1225       unsigned NopSize = EmitNop(*OutStreamer, MinSize, Subtarget->is64Bit(),
 1232   OutStreamer->EmitInstruction(MCI, getSubtargetInfo());
 1238   SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
 1250   SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
 1300   EmitNops(*OutStreamer, NumBytes - EncodedBytes, Subtarget->is64Bit(),
 1329   OutStreamer->AddComment("# XRay Custom Event Log");
 1330   OutStreamer->EmitCodeAlignment(2);
 1331   OutStreamer->EmitLabel(CurSled);
 1336   OutStreamer->EmitBinaryData("\xeb\x0f");
 1359         EmitNops(*OutStreamer, 4, Subtarget->is64Bit(), getSubtargetInfo());
 1388       EmitNops(*OutStreamer, 1, Subtarget->is64Bit(), getSubtargetInfo());
 1390   OutStreamer->AddComment("xray custom event end.");
 1423   OutStreamer->AddComment("# XRay Typed Event Log");
 1424   OutStreamer->EmitCodeAlignment(2);
 1425   OutStreamer->EmitLabel(CurSled);
 1430   OutStreamer->EmitBinaryData("\xeb\x14");
 1455         EmitNops(*OutStreamer, 4, Subtarget->is64Bit(), getSubtargetInfo());
 1489       EmitNops(*OutStreamer, 1, Subtarget->is64Bit(), getSubtargetInfo());
 1491   OutStreamer->AddComment("xray typed event end.");
 1513   OutStreamer->EmitCodeAlignment(2);
 1514   OutStreamer->EmitLabel(CurSled);
 1519   OutStreamer->EmitBytes("\xeb\x09");
 1520   EmitNops(*OutStreamer, 9, Subtarget->is64Bit(), getSubtargetInfo());
 1541   OutStreamer->EmitCodeAlignment(2);
 1542   OutStreamer->EmitLabel(CurSled);
 1549   OutStreamer->EmitInstruction(Ret, getSubtargetInfo());
 1550   EmitNops(*OutStreamer, 10, Subtarget->is64Bit(), getSubtargetInfo());
 1563   OutStreamer->EmitCodeAlignment(2);
 1564   OutStreamer->EmitLabel(CurSled);
 1570   OutStreamer->EmitBytes("\xeb\x09");
 1571   EmitNops(*OutStreamer, 9, Subtarget->is64Bit(), getSubtargetInfo());
 1572   OutStreamer->EmitLabel(Target);
 1582   OutStreamer->AddComment("TAILCALL");
 1586   OutStreamer->EmitInstruction(TC, getSubtargetInfo());
 1750         static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer());
 1783     OutStreamer->EmitWinCFIPushReg(MI->getOperand(0).getImm());
 1787     OutStreamer->EmitWinCFISaveReg(MI->getOperand(0).getImm(),
 1792     OutStreamer->EmitWinCFISaveXMM(MI->getOperand(0).getImm(),
 1797     OutStreamer->EmitWinCFIAllocStack(MI->getOperand(0).getImm());
 1801     OutStreamer->EmitWinCFISetFrame(MI->getOperand(0).getImm(),
 1806     OutStreamer->EmitWinCFIPushFrame(MI->getOperand(0).getImm());
 1810     OutStreamer->EmitWinCFIEndProlog();
 1839       OutStreamer->AddComment("EVEX TO VEX Compression ", false);
 1848     OutStreamer->emitRawComment("MEMBARRIER");
 1855     OutStreamer->AddComment(StringRef("eh_return, addr: %") +
 1861     OutStreamer->AddComment("CLEANUPRET");
 1867     OutStreamer->AddComment("CATCHRET");
 1882     OutStreamer->AddComment("TAILCALL");
 1978     bool HasActiveDwarfFrame = OutStreamer->getNumFrameInfos() &&
 1979                                !OutStreamer->getDwarfFrameInfos().back().End;
 1984       OutStreamer->EmitCFIAdjustCfaOffset(-stackGrowth);
 1988     OutStreamer->EmitLabel(PICBase);
 1995       OutStreamer->EmitCFIAdjustCfaOffset(stackGrowth);
 2013     OutStreamer->EmitLabel(DotSym);
 2120     if (!OutStreamer->isVerboseAsm())
 2151         OutStreamer->AddComment(getShuffleComment(MI, SrcIdx, SrcIdx, Mask));
 2178     if (!OutStreamer->isVerboseAsm())
 2223         OutStreamer->AddComment(getShuffleComment(MI, SrcIdx, SrcIdx, Mask));
 2232     if (!OutStreamer->isVerboseAsm())
 2254         OutStreamer->AddComment(getShuffleComment(MI, 1, 2, Mask));
 2260     if (!OutStreamer->isVerboseAsm())
 2271         OutStreamer->AddComment(getShuffleComment(MI, 1, 2, Mask));
 2277     if (!OutStreamer->isVerboseAsm())
 2288         OutStreamer->AddComment(CS.str());
 2339     if (!OutStreamer->isVerboseAsm())
 2385         OutStreamer->AddComment(CS.str());
 2397         OutStreamer->AddComment(CS.str());
 2432     if (!OutStreamer->isVerboseAsm())
 2484       OutStreamer->AddComment(CS.str());
 2500     SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
 2502     OutStreamer->EmitInstruction(TmpInst, getSubtargetInfo());

   85   return static_cast<XCoreTargetStreamer&>(*OutStreamer->getTargetStreamer());
   96     OutStreamer->EmitSymbolAttribute(SymGlob, MCSA_Global);
   97     OutStreamer->EmitAssignment(SymGlob,
  102       OutStreamer->EmitSymbolAttribute(SymGlob, MCSA_Weak);
  114   OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(GV, TM));
  133     OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Global);
  137       OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Weak);
  153     OutStreamer->EmitSymbolAttribute(GVSym, MCSA_ELF_TypeObject);
  154     OutStreamer->emitELFSize(GVSym, MCConstantExpr::create(Size, OutContext));
  156   OutStreamer->EmitLabel(GVSym);
  162     OutStreamer->EmitZeros(4 - Size);
  182   OutStreamer->EmitLabel(CurrentFnSym);
  271       OutStreamer->EmitRawText(O.str());
  284     OutStreamer->EmitRawText(O.str());
  291   EmitToStreamer(*OutStreamer, TmpInst);

  160   Asm->OutStreamer->EmitLabel(Unit.getLabelBegin());
  195   Asm->OutStreamer->SwitchSection(MOFI->getDwarfStrSection());
  199     Asm->OutStreamer->EmitBytes(Entry.getString());
  220   Asm->OutStreamer->SwitchSection(MOFI->getDwarfDebugNamesSection());
  230   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelNamespaceSection());
  232   Asm->OutStreamer->EmitLabel(SectionBegin);
  238   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelNamesSection());
  240   Asm->OutStreamer->EmitLabel(SectionBegin);
  246   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelObjCSection());
  248   Asm->OutStreamer->EmitLabel(SectionBegin);
  254   Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelTypesSection());
  256   Asm->OutStreamer->EmitLabel(SectionBegin);
  345     Asm->OutStreamer->EmitLabel(BeginLabel);
  351     Asm->OutStreamer->emitFill(Padding, 0x0);
  363     Asm->OutStreamer->EmitIntValue(0, AddressSize);
  364     Asm->OutStreamer->EmitIntValue(0, AddressSize);
  365     Asm->OutStreamer->EmitLabel(EndLabel);
  426         Asm->OutStreamer->EmitIntValue(0, AddressSize);
  427         Asm->OutStreamer->EmitIntValue(0, AddressSize);
  432         Asm->OutStreamer->EmitIntValue(BaseAddressMarker, AddressSize);
  433         Asm->OutStreamer->EmitIntValue(High + Attr.second, AddressSize);
  438       Asm->OutStreamer->EmitIntValue(Low + LocPcOffset, AddressSize);
  439       Asm->OutStreamer->EmitIntValue(High + LocPcOffset, AddressSize);
  441       Asm->OutStreamer->EmitIntValue(Length, 2);
  447       Asm->OutStreamer->EmitBytes(
  468   Asm->OutStreamer->EmitLabel(LineStartSym);
  623   Asm->OutStreamer->EmitLabel(BeginLabel);
  630   Asm->OutStreamer->EmitLabel(HeaderBeginLabel);
  639   Asm->OutStreamer->EmitBytes(Contents.slice(AfterHeaderLengthOffset, Offset));
  648     Asm->OutStreamer->EmitBytes(Translated);
  660     Asm->OutStreamer->EmitBytes(Translated);
  673   Asm->OutStreamer->EmitLabel(HeaderEndLabel);
  676   Asm->OutStreamer->EmitBytes(Contents.slice(Offset, UnitEnd));
  679   Asm->OutStreamer->EmitLabel(EndLabel);
  721   Asm->OutStreamer->SwitchSection(Sec);
  734       Asm->OutStreamer->EmitLabel(BeginLabel);
  743     Asm->OutStreamer->EmitBytes(Name.Name.getString());
  751   Asm->OutStreamer->EmitLabel(EndLabel);

 2521   AP->OutStreamer->SwitchSection(
 2523   AP->OutStreamer->EmitBytes("0");
 2524   AP->OutStreamer->SwitchSection(
 2526   AP->OutStreamer->EmitBytes("0");

  237     Asm.OutStreamer->EmitLabel(EndSymbol);
  248       Asm.OutStreamer->EmitIntValue(Entry.Value, Entry.Length);
  270   Asm.OutStreamer->EmitLabel(UnitStart);
  281   Asm.OutStreamer->EmitLabel(PrologueStart);
  285   Asm.OutStreamer->EmitLabel(PrologueEnd);
  310   Asm.OutStreamer->EmitBytes(Str);