From 6d2d589b06fcb31220bdf5aa09b7a6d5b34ef252 Mon Sep 17 00:00:00 2001 From: Fangrui Song Date: Fri, 14 Feb 2020 19:21:58 -0800 Subject: [PATCH] [MC] De-capitalize another set of MCStreamer::Emit* functions Emit{ValueTo,Code}Alignment Emit{DTP,TP,GP}* EmitSymbolValue etc --- llvm/include/llvm/MC/MCELFStreamer.h | 6 +- llvm/include/llvm/MC/MCObjectStreamer.h | 20 +++--- llvm/include/llvm/MC/MCStreamer.h | 22 +++--- llvm/include/llvm/MC/MCWasmStreamer.h | 4 +- llvm/include/llvm/MC/MCWinCOFFStreamer.h | 2 +- llvm/lib/CodeGen/AsmPrinter/ARMException.cpp | 2 +- llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp | 16 ++--- llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp | 6 +- llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp | 82 +++++++++++----------- llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp | 2 +- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp | 16 ++--- llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp | 4 +- llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp | 2 +- llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp | 26 +++---- llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp | 2 +- llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp | 4 +- llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp | 2 +- llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp | 12 ++-- llvm/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp | 4 +- llvm/lib/CodeGen/AsmPrinter/WasmException.cpp | 4 +- llvm/lib/CodeGen/AsmPrinter/WinException.cpp | 22 +++--- llvm/lib/CodeGen/FaultMaps.cpp | 4 +- llvm/lib/CodeGen/StackMaps.cpp | 8 +-- llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp | 12 ++-- llvm/lib/MC/ConstantPools.cpp | 4 +- llvm/lib/MC/MCAsmInfo.cpp | 2 +- llvm/lib/MC/MCAsmStreamer.cpp | 46 ++++++------ llvm/lib/MC/MCCodeView.cpp | 20 +++--- llvm/lib/MC/MCDwarf.cpp | 54 +++++++------- llvm/lib/MC/MCELFStreamer.cpp | 18 ++--- llvm/lib/MC/MCMachOStreamer.cpp | 14 ++-- llvm/lib/MC/MCNullStreamer.cpp | 2 +- llvm/lib/MC/MCObjectStreamer.cpp | 38 +++++----- llvm/lib/MC/MCParser/AsmParser.cpp | 12 ++-- llvm/lib/MC/MCParser/DarwinAsmParser.cpp | 2 +- llvm/lib/MC/MCParser/ELFAsmParser.cpp | 4 +- llvm/lib/MC/MCStreamer.cpp | 32 ++++----- llvm/lib/MC/MCWasmStreamer.cpp | 8 +-- llvm/lib/MC/MCWin64EH.cpp | 12 ++-- llvm/lib/MC/MCWinCOFFStreamer.cpp | 14 ++-- llvm/lib/MC/MCXCOFFStreamer.cpp | 2 +- llvm/lib/Object/RecordStreamer.cpp | 4 +- llvm/lib/Object/RecordStreamer.h | 2 +- llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp | 24 +++---- .../lib/Target/AArch64/AArch64TargetObjectFile.cpp | 4 +- .../AArch64/MCTargetDesc/AArch64ELFStreamer.cpp | 6 +- .../AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp | 2 +- llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp | 2 +- .../AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp | 20 +++--- llvm/lib/Target/ARM/ARMAsmPrinter.cpp | 34 ++++----- llvm/lib/Target/ARM/ARMMCInstLower.cpp | 6 +- llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp | 10 +-- .../lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp | 12 ++-- llvm/lib/Target/BPF/BTFDebug.cpp | 4 +- .../Target/Hexagon/AsmParser/HexagonAsmParser.cpp | 6 +- llvm/lib/Target/Hexagon/HexagonAsmPrinter.cpp | 8 +-- llvm/lib/Target/Hexagon/HexagonTargetStreamer.h | 2 +- .../Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp | 4 +- llvm/lib/Target/MSP430/MSP430AsmPrinter.cpp | 2 +- llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp | 34 ++++----- .../Target/Mips/MCTargetDesc/MipsELFStreamer.cpp | 14 ++-- .../lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h | 4 +- .../Mips/MCTargetDesc/MipsTargetStreamer.cpp | 8 +-- llvm/lib/Target/Mips/MipsAsmPrinter.cpp | 22 +++--- llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp | 2 +- .../Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp | 6 +- .../Target/PowerPC/MCTargetDesc/PPCELFStreamer.h | 2 +- .../PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp | 8 +-- llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp | 48 ++++++------- llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp | 2 +- llvm/lib/Target/Sparc/SparcAsmPrinter.cpp | 6 +- .../Target/SystemZ/AsmParser/SystemZAsmParser.cpp | 2 +- llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp | 14 ++-- llvm/lib/Target/TargetLoweringObjectFile.cpp | 2 +- .../WebAssembly/AsmParser/WebAssemblyAsmParser.cpp | 2 +- llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp | 4 +- .../X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp | 8 +-- llvm/lib/Target/X86/X86AsmPrinter.cpp | 2 +- llvm/lib/Target/X86/X86MCInstLower.cpp | 36 +++++----- llvm/lib/Target/XCore/XCoreAsmPrinter.cpp | 4 +- llvm/test/MC/RISCV/align.s | 2 +- llvm/tools/dsymutil/DwarfStreamer.cpp | 32 ++++----- llvm/tools/llvm-exegesis/lib/SnippetFile.cpp | 2 +- llvm/tools/llvm-mca/CodeRegionGenerator.cpp | 2 +- llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp | 8 +-- 85 files changed, 498 insertions(+), 498 deletions(-) diff --git a/llvm/include/llvm/MC/MCELFStreamer.h b/llvm/include/llvm/MC/MCELFStreamer.h index fbbd3de..9ee3395 100644 --- a/llvm/include/llvm/MC/MCELFStreamer.h +++ b/llvm/include/llvm/MC/MCELFStreamer.h @@ -40,7 +40,7 @@ public: void InitSections(bool NoExecStack) override; void ChangeSection(MCSection *Section, const MCExpr *Subsection) override; - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset) override; void emitAssemblerFlag(MCAssemblerFlag Flag) override; @@ -63,12 +63,12 @@ public: SMLoc L = SMLoc()) override; void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment = 0) override; - void EmitValueImpl(const MCExpr *Value, unsigned Size, + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()) override; void EmitIdent(StringRef IdentString) override; - void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override; + void emitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override; void emitCGProfileEntry(const MCSymbolRefExpr *From, const MCSymbolRefExpr *To, uint64_t Count) override; diff --git a/llvm/include/llvm/MC/MCObjectStreamer.h b/llvm/include/llvm/MC/MCObjectStreamer.h index 32a24e9..164a1fc 100644 --- a/llvm/include/llvm/MC/MCObjectStreamer.h +++ b/llvm/include/llvm/MC/MCObjectStreamer.h @@ -113,11 +113,11 @@ public: /// \name MCStreamer Interface /// @{ - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; virtual void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset); void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override; - void EmitValueImpl(const MCExpr *Value, unsigned Size, + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()) override; void emitULEB128Value(const MCExpr *Value) override; void emitSLEB128Value(const MCExpr *Value) override; @@ -133,10 +133,10 @@ public: void EmitBundleLock(bool AlignToEnd) override; void EmitBundleUnlock() override; void emitBytes(StringRef Data) override; - void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, + void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, unsigned ValueSize = 1, unsigned MaxBytesToEmit = 0) override; - void EmitCodeAlignment(unsigned ByteAlignment, + void emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit = 0) override; void emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc) override; @@ -164,12 +164,12 @@ public: void EmitCVStringTableDirective() override; void EmitCVFileChecksumsDirective() override; void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override; - void EmitDTPRel32Value(const MCExpr *Value) override; - void EmitDTPRel64Value(const MCExpr *Value) override; - void EmitTPRel32Value(const MCExpr *Value) override; - void EmitTPRel64Value(const MCExpr *Value) override; - void EmitGPRel32Value(const MCExpr *Value) override; - void EmitGPRel64Value(const MCExpr *Value) override; + void emitDTPRel32Value(const MCExpr *Value) override; + void emitDTPRel64Value(const MCExpr *Value) override; + void emitTPRel32Value(const MCExpr *Value) override; + void emitTPRel64Value(const MCExpr *Value) override; + void emitGPRel32Value(const MCExpr *Value) override; + void emitGPRel64Value(const MCExpr *Value) override; bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, const MCExpr *Expr, SMLoc Loc, const MCSubtargetInfo &STI) override; diff --git a/llvm/include/llvm/MC/MCStreamer.h b/llvm/include/llvm/MC/MCStreamer.h index 7d71a00..25c0e4f 100644 --- a/llvm/include/llvm/MC/MCStreamer.h +++ b/llvm/include/llvm/MC/MCStreamer.h @@ -453,7 +453,7 @@ public: /// used in an assignment. // FIXME: These emission are non-const because we mutate the symbol to // add the section we're emitting it to later. - virtual void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()); + virtual void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()); virtual void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol); @@ -647,7 +647,7 @@ public: /// \param Size - The size of the integer (in bytes) to emit. This must /// match a native machine width. /// \param Loc - The location of the expression for error reporting. - virtual void EmitValueImpl(const MCExpr *Value, unsigned Size, + virtual void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()); void EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()); @@ -684,7 +684,7 @@ public: /// Special case of EmitValue that avoids the client having to pass in /// a MCExpr for MCSymbols. - void EmitSymbolValue(const MCSymbol *Sym, unsigned Size, + void emitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative = false); /// Emit the expression \p Value into the output as a dtprel @@ -692,42 +692,42 @@ public: /// /// This is used to implement assembler directives such as .dtpreldword on /// targets that support them. - virtual void EmitDTPRel64Value(const MCExpr *Value); + virtual void emitDTPRel64Value(const MCExpr *Value); /// Emit the expression \p Value into the output as a dtprel /// (32-bit DTP relative) value. /// /// This is used to implement assembler directives such as .dtprelword on /// targets that support them. - virtual void EmitDTPRel32Value(const MCExpr *Value); + virtual void emitDTPRel32Value(const MCExpr *Value); /// Emit the expression \p Value into the output as a tprel /// (64-bit TP relative) value. /// /// This is used to implement assembler directives such as .tpreldword on /// targets that support them. - virtual void EmitTPRel64Value(const MCExpr *Value); + virtual void emitTPRel64Value(const MCExpr *Value); /// Emit the expression \p Value into the output as a tprel /// (32-bit TP relative) value. /// /// This is used to implement assembler directives such as .tprelword on /// targets that support them. - virtual void EmitTPRel32Value(const MCExpr *Value); + virtual void emitTPRel32Value(const MCExpr *Value); /// Emit the expression \p Value into the output as a gprel64 (64-bit /// GP relative) value. /// /// This is used to implement assembler directives such as .gpdword on /// targets that support them. - virtual void EmitGPRel64Value(const MCExpr *Value); + virtual void emitGPRel64Value(const MCExpr *Value); /// Emit the expression \p Value into the output as a gprel32 (32-bit /// GP relative) value. /// /// This is used to implement assembler directives such as .gprel32 on /// targets that support them. - virtual void EmitGPRel32Value(const MCExpr *Value); + virtual void emitGPRel32Value(const MCExpr *Value); /// Emit NumBytes bytes worth of the value specified by FillValue. /// This implements directives such as '.space'. @@ -775,7 +775,7 @@ public: /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If /// the alignment cannot be reached in this many bytes, no bytes are /// emitted. - virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, + virtual void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, unsigned ValueSize = 1, unsigned MaxBytesToEmit = 0); @@ -789,7 +789,7 @@ public: /// \param MaxBytesToEmit - The maximum numbers of bytes to emit, or 0. If /// the alignment cannot be reached in this many bytes, no bytes are /// emitted. - virtual void EmitCodeAlignment(unsigned ByteAlignment, + virtual void emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit = 0); /// Emit some number of copies of \p Value until the byte offset \p diff --git a/llvm/include/llvm/MC/MCWasmStreamer.h b/llvm/include/llvm/MC/MCWasmStreamer.h index 7c9aa4f..78c93d4 100644 --- a/llvm/include/llvm/MC/MCWasmStreamer.h +++ b/llvm/include/llvm/MC/MCWasmStreamer.h @@ -63,12 +63,12 @@ public: SMLoc Loc = SMLoc()) override; void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment = 0) override; - void EmitValueImpl(const MCExpr *Value, unsigned Size, + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()) override; void EmitIdent(StringRef IdentString) override; - void EmitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override; + void emitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override; void FinishImpl() override; diff --git a/llvm/include/llvm/MC/MCWinCOFFStreamer.h b/llvm/include/llvm/MC/MCWinCOFFStreamer.h index 24b0fb8..2603a8f8 100644 --- a/llvm/include/llvm/MC/MCWinCOFFStreamer.h +++ b/llvm/include/llvm/MC/MCWinCOFFStreamer.h @@ -40,7 +40,7 @@ public: /// \{ void InitSections(bool NoExecStack) override; - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; void emitAssemblerFlag(MCAssemblerFlag Flag) override; void emitThumbFunc(MCSymbol *Func) override; bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override; diff --git a/llvm/lib/CodeGen/AsmPrinter/ARMException.cpp b/llvm/lib/CodeGen/AsmPrinter/ARMException.cpp index cc516e6..b634b24 100644 --- a/llvm/lib/CodeGen/AsmPrinter/ARMException.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/ARMException.cpp @@ -112,7 +112,7 @@ void ARMException::emitTypeInfos(unsigned TTypeEncoding, Asm->emitTTypeReference(GV, TTypeEncoding); } - Asm->OutStreamer->EmitLabel(TTBaseLabel); + Asm->OutStreamer->emitLabel(TTBaseLabel); // Emit the Exception Specifications. if (VerboseAsm && !FilterIds.empty()) { diff --git a/llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp b/llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp index 7b84134..a88bd08 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp @@ -337,7 +337,7 @@ void AppleAccelTableWriter::emitData() const { PrevHash != Hash->HashValue) Asm->emitInt32(0); // Remember to emit the label for our offset. - Asm->OutStreamer->EmitLabel(Hash->Sym); + Asm->OutStreamer->emitLabel(Hash->Sym); Asm->OutStreamer->AddComment(Hash->Name.getString()); Asm->emitDwarfStringOffset(Hash->Name); Asm->OutStreamer->AddComment("Num DIEs"); @@ -370,7 +370,7 @@ void Dwarf5AccelTableWriter::Header::emit( Asm->OutStreamer->AddComment("Header: unit length"); Asm->emitLabelDifference(Ctx.ContributionEnd, Ctx.ContributionStart, sizeof(uint32_t)); - Asm->OutStreamer->EmitLabel(Ctx.ContributionStart); + Asm->OutStreamer->emitLabel(Ctx.ContributionStart); Asm->OutStreamer->AddComment("Header: version"); Asm->emitInt16(Version); Asm->OutStreamer->AddComment("Header: padding"); @@ -453,7 +453,7 @@ void Dwarf5AccelTableWriter::emitStringOffsets() const { template void Dwarf5AccelTableWriter::emitAbbrevs() const { - Asm->OutStreamer->EmitLabel(AbbrevStart); + Asm->OutStreamer->emitLabel(AbbrevStart); for (const auto &Abbrev : Abbreviations) { Asm->OutStreamer->AddComment("Abbrev code"); assert(Abbrev.first != 0); @@ -469,7 +469,7 @@ void Dwarf5AccelTableWriter::emitAbbrevs() const { Asm->emitULEB128(0, "End of abbrev"); } Asm->emitULEB128(0, "End of abbrev list"); - Asm->OutStreamer->EmitLabel(AbbrevEnd); + Asm->OutStreamer->emitLabel(AbbrevEnd); } template @@ -498,11 +498,11 @@ void Dwarf5AccelTableWriter::emitEntry(const DataT &Entry) const { } template void Dwarf5AccelTableWriter::emitData() const { - Asm->OutStreamer->EmitLabel(EntryPool); + Asm->OutStreamer->emitLabel(EntryPool); for (auto &Bucket : Contents.getBuckets()) { for (auto *Hash : Bucket) { // Remember to emit the label for our offset. - Asm->OutStreamer->EmitLabel(Hash->Sym); + Asm->OutStreamer->emitLabel(Hash->Sym); for (const auto *Value : Hash->Values) emitEntry(*static_cast(Value)); Asm->OutStreamer->AddComment("End of list: " + Hash->Name.getString()); @@ -537,8 +537,8 @@ template void Dwarf5AccelTableWriter::emit() const { emitOffsets(EntryPool); emitAbbrevs(); emitData(); - Asm->OutStreamer->EmitValueToAlignment(4, 0); - Asm->OutStreamer->EmitLabel(ContributionEnd); + Asm->OutStreamer->emitValueToAlignment(4, 0); + Asm->OutStreamer->emitLabel(ContributionEnd); } void llvm::emitAppleAccelTableImpl(AsmPrinter *Asm, AccelTableBase &Contents, diff --git a/llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp b/llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp index cb6f229..7dd93aa 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AddressPool.cpp @@ -32,7 +32,7 @@ MCSymbol *AddressPool::emitHeader(AsmPrinter &Asm, MCSection *Section) { Asm.OutStreamer->AddComment("Length of contribution"); Asm.emitLabelDifference(EndLabel, BeginLabel, 4); // TODO: Support DWARF64 format. - Asm.OutStreamer->EmitLabel(BeginLabel); + Asm.OutStreamer->emitLabel(BeginLabel); Asm.OutStreamer->AddComment("DWARF version number"); Asm.emitInt16(Asm.getDwarfVersion()); Asm.OutStreamer->AddComment("Address size"); @@ -58,7 +58,7 @@ void AddressPool::emit(AsmPrinter &Asm, MCSection *AddrSection) { // Define the symbol that marks the start of the contribution. // It is referenced via DW_AT_addr_base. - Asm.OutStreamer->EmitLabel(AddressTableBaseSym); + Asm.OutStreamer->emitLabel(AddressTableBaseSym); // Order the address pool entries by ID SmallVector Entries(Pool.size()); @@ -73,5 +73,5 @@ void AddressPool::emit(AsmPrinter &Asm, MCSection *AddrSection) { Asm.OutStreamer->EmitValue(Entry, Asm.getDataLayout().getPointerSize()); if (EndLabel) - Asm.OutStreamer->EmitLabel(EndLabel); + Asm.OutStreamer->emitLabel(EndLabel); } diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 241e67e..9a7b541 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -608,7 +608,7 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { OutStreamer->SwitchSection(TheSection); emitAlignment(Alignment, GV); - OutStreamer->EmitLabel(MangSym); + OutStreamer->emitLabel(MangSym); emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer()); @@ -622,17 +622,17 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { OutStreamer->SwitchSection(TLVSect); // Emit the linkage here. emitLinkage(GV, GVSym); - OutStreamer->EmitLabel(GVSym); + OutStreamer->emitLabel(GVSym); // Three pointers in size: // - __tlv_bootstrap - used to make sure support exists // - spare pointer, used when mapped by the runtime // - pointer to mangled symbol above with initializer unsigned PtrSize = DL.getPointerTypeSize(GV->getType()); - OutStreamer->EmitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"), + OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("_tlv_bootstrap"), PtrSize); OutStreamer->EmitIntValue(0, PtrSize); - OutStreamer->EmitSymbolValue(MangSym, PtrSize); + OutStreamer->emitSymbolValue(MangSym, PtrSize); OutStreamer->AddBlankLine(); return; @@ -645,10 +645,10 @@ void AsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { emitLinkage(GV, EmittedInitSym); emitAlignment(Alignment, GV); - OutStreamer->EmitLabel(EmittedInitSym); + OutStreamer->emitLabel(EmittedInitSym); MCSymbol *LocalAlias = getSymbolPreferLocal(*GV); if (LocalAlias != EmittedInitSym) - OutStreamer->EmitLabel(LocalAlias); + OutStreamer->emitLabel(LocalAlias); emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer()); @@ -713,7 +713,7 @@ void AsmPrinter::emitFunctionHeader() { // and use the .alt_entry attribute to mark the function's real entry point // as an alternative entry point to the prefix-data symbol. MCSymbol *PrefixSym = OutContext.createLinkerPrivateTempSymbol(); - OutStreamer->EmitLabel(PrefixSym); + OutStreamer->emitLabel(PrefixSym); emitGlobalConstant(F.getParent()->getDataLayout(), F.getPrefixData()); @@ -737,7 +737,7 @@ void AsmPrinter::emitFunctionHeader() { if (PatchableFunctionPrefix) { CurrentPatchableFunctionEntrySym = OutContext.createLinkerPrivateTempSymbol(); - OutStreamer->EmitLabel(CurrentPatchableFunctionEntrySym); + OutStreamer->emitLabel(CurrentPatchableFunctionEntrySym); emitNops(PatchableFunctionPrefix); } else if (PatchableFunctionEntry) { // May be reassigned when emitting the body, to reference the label after @@ -759,11 +759,11 @@ void AsmPrinter::emitFunctionHeader() { if (CurrentFnBegin) { if (MAI->useAssignmentForEHBegin()) { MCSymbol *CurPos = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(CurPos); + OutStreamer->emitLabel(CurPos); OutStreamer->emitAssignment(CurrentFnBegin, MCSymbolRefExpr::create(CurPos, OutContext)); } else { - OutStreamer->EmitLabel(CurrentFnBegin); + OutStreamer->emitLabel(CurrentFnBegin); } } @@ -793,12 +793,12 @@ void AsmPrinter::emitFunctionEntryLabel() { report_fatal_error("'" + Twine(CurrentFnSym->getName()) + "' label emitted multiple times to assembly file"); - OutStreamer->EmitLabel(CurrentFnSym); + OutStreamer->emitLabel(CurrentFnSym); if (TM.getTargetTriple().isOSBinFormatELF()) { MCSymbol *Sym = getSymbolPreferLocal(MF->getFunction()); if (Sym != CurrentFnSym) - OutStreamer->EmitLabel(Sym); + OutStreamer->emitLabel(Sym); } } @@ -1045,7 +1045,7 @@ void AsmPrinter::emitStackSizeSection(const MachineFunction &MF) { const MCSymbol *FunctionSymbol = getFunctionBegin(); uint64_t StackSize = FrameInfo.getStackSize(); - OutStreamer->EmitSymbolValue(FunctionSymbol, TM.getProgramPointerSize()); + OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize()); OutStreamer->emitULEB128IntValue(StackSize); OutStreamer->PopSection(); @@ -1108,7 +1108,7 @@ void AsmPrinter::emitFunctionBody() { // If there is a pre-instruction symbol, emit a label for it here. if (MCSymbol *S = MI.getPreInstrSymbol()) - OutStreamer->EmitLabel(S); + OutStreamer->emitLabel(S); if (ShouldPrintDebugScopes) { for (const HandlerInfo &HI : Handlers) { @@ -1132,7 +1132,7 @@ void AsmPrinter::emitFunctionBody() { case TargetOpcode::ANNOTATION_LABEL: case TargetOpcode::EH_LABEL: case TargetOpcode::GC_LABEL: - OutStreamer->EmitLabel(MI.getOperand(0).getMCSymbol()); + OutStreamer->emitLabel(MI.getOperand(0).getMCSymbol()); break; case TargetOpcode::INLINEASM: case TargetOpcode::INLINEASM_BR: @@ -1163,7 +1163,7 @@ void AsmPrinter::emitFunctionBody() { // If there is a post-instruction symbol, emit a label for it here. if (MCSymbol *S = MI.getPostInstrSymbol()) - OutStreamer->EmitLabel(S); + OutStreamer->emitLabel(S); if (ShouldPrintDebugScopes) { for (const HandlerInfo &HI : Handlers) { @@ -1216,7 +1216,7 @@ void AsmPrinter::emitFunctionBody() { if (Sym->isDefined()) continue; OutStreamer->AddComment("Address of block that was removed by CodeGen"); - OutStreamer->EmitLabel(Sym); + OutStreamer->emitLabel(Sym); } // Emit target-specific gunk after the function body. @@ -1226,7 +1226,7 @@ void AsmPrinter::emitFunctionBody() { MAI->hasDotTypeDotSizeDirective()) { // Create a symbol for the end of function. CurrentFnEnd = createTempSymbol("func_end"); - OutStreamer->EmitLabel(CurrentFnEnd); + OutStreamer->emitLabel(CurrentFnEnd); } // If the target wants a .size directive for the size of the function, emit @@ -1483,8 +1483,8 @@ bool AsmPrinter::doFinalization(Module &M) { emitAlignment(Align(DL.getPointerSize())); for (const auto &Stub : Stubs) { - OutStreamer->EmitLabel(Stub.first); - OutStreamer->EmitSymbolValue(Stub.second.getPointer(), + OutStreamer->emitLabel(Stub.first); + OutStreamer->emitSymbolValue(Stub.second.getPointer(), DL.getPointerSize()); } } @@ -1510,8 +1510,8 @@ bool AsmPrinter::doFinalization(Module &M) { COFF::IMAGE_COMDAT_SELECT_ANY)); emitAlignment(Align(DL.getPointerSize())); OutStreamer->emitSymbolAttribute(Stub.first, MCSA_Global); - OutStreamer->EmitLabel(Stub.first); - OutStreamer->EmitSymbolValue(Stub.second.getPointer(), + OutStreamer->emitLabel(Stub.first); + OutStreamer->emitSymbolValue(Stub.second.getPointer(), DL.getPointerSize()); } } @@ -1583,10 +1583,10 @@ bool AsmPrinter::doFinalization(Module &M) { MCSymbol *AddrSymbol = OutContext.getOrCreateSymbol(StringRef("__morestack_addr")); - OutStreamer->EmitLabel(AddrSymbol); + OutStreamer->emitLabel(AddrSymbol); unsigned PtrSize = MAI->getCodePointerSize(); - OutStreamer->EmitSymbolValue(GetExternalSymbolSymbol("__morestack"), + OutStreamer->emitSymbolValue(GetExternalSymbolSymbol("__morestack"), PtrSize); } @@ -1838,7 +1838,7 @@ void AsmPrinter::emitConstantPool() { Type *Ty = CPE.getType(); Offset = NewOffset + getDataLayout().getTypeAllocSize(Ty); - OutStreamer->EmitLabel(Sym); + OutStreamer->emitLabel(Sym); if (CPE.isMachineConstantPoolEntry()) emitMachineConstantPoolValue(CPE.Val.MachineCPVal); else @@ -1912,14 +1912,14 @@ void AsmPrinter::emitJumpTableInfo() { // FIXME: This doesn't have to have any specific name, just any randomly // named and numbered local label started with 'l' would work. Simplify // GetJTISymbol. - OutStreamer->EmitLabel(GetJTISymbol(JTI, true)); + OutStreamer->emitLabel(GetJTISymbol(JTI, true)); MCSymbol* JTISymbol = GetJTISymbol(JTI); if (TM.getTargetTriple().isOSBinFormatXCOFF()) { cast(JTISymbol)->setContainingCsect( cast(TLOF.getSectionForJumpTable(F, TM))); } - OutStreamer->EmitLabel(JTISymbol); + OutStreamer->emitLabel(JTISymbol); for (unsigned ii = 0, ee = JTBBs.size(); ii != ee; ++ii) emitJumpTableEntry(MJTI, JTBBs[ii], JTI); @@ -1952,7 +1952,7 @@ void AsmPrinter::emitJumpTableEntry(const MachineJumpTableInfo *MJTI, // with a relocation as gp-relative, e.g.: // .gprel32 LBB123 MCSymbol *MBBSym = MBB->getSymbol(); - OutStreamer->EmitGPRel32Value(MCSymbolRefExpr::create(MBBSym, OutContext)); + OutStreamer->emitGPRel32Value(MCSymbolRefExpr::create(MBBSym, OutContext)); return; } @@ -1961,7 +1961,7 @@ void AsmPrinter::emitJumpTableEntry(const MachineJumpTableInfo *MJTI, // with a relocation as gp-relative, e.g.: // .gpdword LBB123 MCSymbol *MBBSym = MBB->getSymbol(); - OutStreamer->EmitGPRel64Value(MCSymbolRefExpr::create(MBBSym, OutContext)); + OutStreamer->emitGPRel64Value(MCSymbolRefExpr::create(MBBSym, OutContext)); return; } @@ -2224,9 +2224,9 @@ void AsmPrinter::emitAlignment(Align Alignment, const GlobalObject *GV) const { return; // 1-byte aligned: no need to emit alignment. if (getCurrentSection()->getKind().isText()) - OutStreamer->EmitCodeAlignment(Alignment.value()); + OutStreamer->emitCodeAlignment(Alignment.value()); else - OutStreamer->EmitValueToAlignment(Alignment.value()); + OutStreamer->emitValueToAlignment(Alignment.value()); } //===----------------------------------------------------------------------===// @@ -3009,7 +3009,7 @@ void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { // their corresponding BB's address taken in IR if (BB->hasAddressTaken()) for (MCSymbol *Sym : MMI->getAddrLabelSymbolToEmit(BB)) - OutStreamer->EmitLabel(Sym); + OutStreamer->emitLabel(Sym); } // Print some verbose block comments. @@ -3038,7 +3038,7 @@ void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) { } else { if (isVerbose() && MBB.hasLabelMustBeEmitted()) OutStreamer->AddComment("Label of block must be emitted"); - OutStreamer->EmitLabel(MBB.getSymbol()); + OutStreamer->emitLabel(MBB.getSymbol()); } } @@ -3163,8 +3163,8 @@ void AsmPrinterHandler::markFunctionEnd() {} // into this table will be given to your handler as a patch point identifier. void AsmPrinter::XRayFunctionEntry::emit(int Bytes, MCStreamer *Out, const MCSymbol *CurrentFnSym) const { - Out->EmitSymbolValue(Sled, Bytes); - Out->EmitSymbolValue(CurrentFnSym, Bytes); + Out->emitSymbolValue(Sled, Bytes); + Out->emitSymbolValue(CurrentFnSym, Bytes); auto Kind8 = static_cast(Kind); Out->emitBinaryData(StringRef(reinterpret_cast(&Kind8), 1)); Out->emitBinaryData( @@ -3216,20 +3216,20 @@ void AsmPrinter::emitXRayTable() { // range of sleds associated with a function. MCSymbol *SledsStart = OutContext.createTempSymbol("xray_sleds_start", true); OutStreamer->SwitchSection(InstMap); - OutStreamer->EmitLabel(SledsStart); + OutStreamer->emitLabel(SledsStart); for (const auto &Sled : Sleds) Sled.emit(WordSizeBytes, OutStreamer.get(), CurrentFnSym); MCSymbol *SledsEnd = OutContext.createTempSymbol("xray_sleds_end", true); - OutStreamer->EmitLabel(SledsEnd); + OutStreamer->emitLabel(SledsEnd); // We then emit a single entry in the index per function. We use the symbols // that bound the instrumentation map as the range for a specific function. // Each entry here will be 2 * word size aligned, as we're writing down two // pointers. This should work for both 32-bit and 64-bit platforms. OutStreamer->SwitchSection(FnSledIndex); - OutStreamer->EmitCodeAlignment(2 * WordSizeBytes); - OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes, false); - OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes, false); + OutStreamer->emitCodeAlignment(2 * WordSizeBytes); + OutStreamer->emitSymbolValue(SledsStart, WordSizeBytes, false); + OutStreamer->emitSymbolValue(SledsEnd, WordSizeBytes, false); OutStreamer->SwitchSection(PrevSection); Sleds.clear(); } @@ -3285,7 +3285,7 @@ void AsmPrinter::emitPatchableFunctionEntries() { "__patchable_function_entries", ELF::SHT_PROGBITS, Flags)); } emitAlignment(Align(PointerSize)); - OutStreamer->EmitSymbolValue(CurrentPatchableFunctionEntrySym, PointerSize); + OutStreamer->emitSymbolValue(CurrentPatchableFunctionEntrySym, PointerSize); } } diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp index 0fbd7da..cc1b040 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp @@ -160,7 +160,7 @@ void AsmPrinter::emitDwarfSymbolReference(const MCSymbol *Label, // If the format uses relocations with dwarf, refer to the symbol directly. if (MAI->doesDwarfUseRelocationsAcrossSections()) { - OutStreamer->EmitSymbolValue(Label, 4); + OutStreamer->emitSymbolValue(Label, 4); return; } } diff --git a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp index efefaf7..48072b2 100644 --- a/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp @@ -549,7 +549,7 @@ void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL, } void CodeViewDebug::emitCodeViewMagicVersion() { - OS.EmitValueToAlignment(4); + OS.emitValueToAlignment(4); OS.AddComment("Debug section magic"); OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4); } @@ -674,7 +674,7 @@ void CodeViewDebug::emitTypeGlobalHashes() { // hardcoded to version 0, SHA1. OS.SwitchSection(Asm->getObjFileLowering().getCOFFGlobalTypeHashesSection()); - OS.EmitValueToAlignment(4); + OS.emitValueToAlignment(4); OS.AddComment("Magic"); OS.EmitIntValue(COFF::DEBUG_HASHES_SECTION_MAGIC, 4); OS.AddComment("Section Version"); @@ -2918,14 +2918,14 @@ MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) { OS.EmitIntValue(unsigned(Kind), 4); OS.AddComment("Subsection size"); OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4); - OS.EmitLabel(BeginLabel); + OS.emitLabel(BeginLabel); return EndLabel; } void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) { - OS.EmitLabel(EndLabel); + OS.emitLabel(EndLabel); // Every subsection must be aligned to a 4-byte boundary. - OS.EmitValueToAlignment(4); + OS.emitValueToAlignment(4); } static StringRef getSymbolName(SymbolKind SymKind) { @@ -2940,7 +2940,7 @@ MCSymbol *CodeViewDebug::beginSymbolRecord(SymbolKind SymKind) { *EndLabel = MMI->getContext().createTempSymbol(); OS.AddComment("Record length"); OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2); - OS.EmitLabel(BeginLabel); + OS.emitLabel(BeginLabel); if (OS.isVerboseAsm()) OS.AddComment("Record kind: " + getSymbolName(SymKind)); OS.EmitIntValue(unsigned(SymKind), 2); @@ -2952,8 +2952,8 @@ void CodeViewDebug::endSymbolRecord(MCSymbol *SymEnd) { // an extra copy of every symbol record in LLD. This increases object file // size by less than 1% in the clang build, and is compatible with the Visual // C++ linker. - OS.EmitValueToAlignment(4); - OS.EmitLabel(SymEnd); + OS.emitValueToAlignment(4); + OS.emitLabel(SymEnd); } void CodeViewDebug::emitEndSymbolRecord(SymbolKind EndKind) { diff --git a/llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp b/llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp index f95c9a3..86528ac 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp @@ -282,7 +282,7 @@ void DebugHandlerBase::beginInstruction(const MachineInstr *MI) { if (!PrevLabel) { PrevLabel = MMI->getContext().createTempSymbol(); - Asm->OutStreamer->EmitLabel(PrevLabel); + Asm->OutStreamer->emitLabel(PrevLabel); } I->second = PrevLabel; } @@ -314,7 +314,7 @@ void DebugHandlerBase::endInstruction() { // We need a label after this instruction. if (!PrevLabel) { PrevLabel = MMI->getContext().createTempSymbol(); - Asm->OutStreamer->EmitLabel(PrevLabel); + Asm->OutStreamer->emitLabel(PrevLabel); } I->second = PrevLabel; } diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp index ea94067..4a570db 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp @@ -1131,7 +1131,7 @@ void DwarfCompileUnit::emitHeader(bool UseOffsets) { // Don't bother labeling the .dwo unit, as its offset isn't used. if (!Skeleton && !DD->useSectionsAsReferences()) { LabelBegin = Asm->createTempSymbol("cu_begin"); - Asm->OutStreamer->EmitLabel(LabelBegin); + Asm->OutStreamer->emitLabel(LabelBegin); } dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 689a633..32dec4f 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -2172,7 +2172,7 @@ void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name, MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end"); Asm->emitLabelDifference(EndLabel, BeginLabel, 4); - Asm->OutStreamer->EmitLabel(BeginLabel); + Asm->OutStreamer->emitLabel(BeginLabel); Asm->OutStreamer->AddComment("DWARF Version"); Asm->emitInt16(dwarf::DW_PUBNAMES_VERSION); @@ -2205,7 +2205,7 @@ void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name, Asm->OutStreamer->AddComment("End Mark"); Asm->emitInt32(0); - Asm->OutStreamer->EmitLabel(EndLabel); + Asm->OutStreamer->emitLabel(EndLabel); } /// Emit null-terminated strings into a debug str section. @@ -2364,7 +2364,7 @@ static void emitListsTableHeaderStart(AsmPrinter *Asm, // Build the table header, which starts with the length field. Asm->OutStreamer->AddComment("Length"); Asm->emitLabelDifference(TableEnd, TableStart, 4); - Asm->OutStreamer->EmitLabel(TableStart); + Asm->OutStreamer->emitLabel(TableStart); // Version number (DWARF v5 and later). Asm->OutStreamer->AddComment("Version"); Asm->emitInt16(Asm->OutStreamer->getContext().getDwarfVersion()); @@ -2387,7 +2387,7 @@ static MCSymbol *emitRnglistsTableHeader(AsmPrinter *Asm, Asm->OutStreamer->AddComment("Offset entry count"); Asm->emitInt32(Holder.getRangeLists().size()); - Asm->OutStreamer->EmitLabel(Holder.getRnglistsTableBaseSym()); + Asm->OutStreamer->emitLabel(Holder.getRnglistsTableBaseSym()); for (const RangeSpanList &List : Holder.getRangeLists()) Asm->emitLabelDifference(List.Label, Holder.getRnglistsTableBaseSym(), 4); @@ -2408,7 +2408,7 @@ static MCSymbol *emitLoclistsTableHeader(AsmPrinter *Asm, Asm->OutStreamer->AddComment("Offset entry count"); Asm->emitInt32(DebugLocs.getLists().size()); - Asm->OutStreamer->EmitLabel(DebugLocs.getSym()); + Asm->OutStreamer->emitLabel(DebugLocs.getSym()); for (const auto &List : DebugLocs.getLists()) Asm->emitLabelDifference(List.Label, DebugLocs.getSym(), 4); @@ -2429,7 +2429,7 @@ static void emitRangeList( bool UseDwarf5 = DD.getDwarfVersion() >= 5; // Emit our symbol so we can find the beginning of the range. - Asm->OutStreamer->EmitLabel(Sym); + Asm->OutStreamer->emitLabel(Sym); // Gather all the ranges that apply to the same section so they can share // a base address entry. @@ -2450,7 +2450,7 @@ static void emitRangeList( BaseIsSet = true; Asm->OutStreamer->EmitIntValue(-1, Size); Asm->OutStreamer->AddComment(" base address"); - Asm->OutStreamer->EmitSymbolValue(Base, Size); + Asm->OutStreamer->emitSymbolValue(Base, Size); } else if (NewBase != Begin || P.second.size() > 1) { // Only use a base address if // * the existing pool address doesn't match (NewBase != Begin) @@ -2495,8 +2495,8 @@ static void emitRangeList( Asm->OutStreamer->AddComment(" length"); Asm->emitLabelDifferenceAsULEB128(End, Begin); } else { - Asm->OutStreamer->EmitSymbolValue(Begin, Size); - Asm->OutStreamer->EmitSymbolValue(End, Size); + Asm->OutStreamer->emitSymbolValue(Begin, Size); + Asm->OutStreamer->emitSymbolValue(End, Size); } EmitPayload(*RS); } @@ -2538,7 +2538,7 @@ void DwarfDebug::emitDebugLocImpl(MCSection *Sec) { emitLocList(*this, Asm, List); if (TableEnd) - Asm->OutStreamer->EmitLabel(TableEnd); + Asm->OutStreamer->emitLabel(TableEnd); } // Emit locations into the .debug_loc/.debug_loclists section. @@ -2561,7 +2561,7 @@ void DwarfDebug::emitDebugLocDWO() { for (const auto &List : DebugLocs.getLists()) { Asm->OutStreamer->SwitchSection( Asm->getObjFileLowering().getDwarfLocDWOSection()); - Asm->OutStreamer->EmitLabel(List.Label); + Asm->OutStreamer->emitLabel(List.Label); for (const auto &Entry : DebugLocs.getEntries(List)) { // GDB only supports startx_length in pre-standard split-DWARF. @@ -2776,7 +2776,7 @@ void DwarfDebug::emitDebugRangesImpl(const DwarfFile &Holder, MCSection *Section emitRangeList(*this, Asm, List); if (TableEnd) - Asm->OutStreamer->EmitLabel(TableEnd); + Asm->OutStreamer->emitLabel(TableEnd); } /// Emit address ranges into the .debug_ranges section or into the DWARF v5 @@ -2839,7 +2839,7 @@ void DwarfDebug::emitDebugMacinfoImpl(MCSection *Section) { if (Macros.empty()) continue; Asm->OutStreamer->SwitchSection(Section); - Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin()); + Asm->OutStreamer->emitLabel(U.getMacroLabelBegin()); handleMacroNodes(Macros, U); Asm->OutStreamer->AddComment("End Of Macro List Mark"); Asm->emitInt8(0); diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp index e5c4db5..812e638 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp @@ -53,7 +53,7 @@ void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) { Asm->emitDwarfDIE(TheU->getUnitDie()); if (MCSymbol *EndLabel = TheU->getEndLabel()) - Asm->OutStreamer->EmitLabel(EndLabel); + Asm->OutStreamer->emitLabel(EndLabel); } // Compute the size and offset for each DIE. diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp index a899294..6a0bb81 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfStringPool.cpp @@ -71,7 +71,7 @@ void DwarfStringPool::emitStringOffsetsTableHeader(AsmPrinter &Asm, // referenced by most unit headers via DW_AT_str_offsets_base. // Split units do not use the attribute. if (StartSym) - Asm.OutStreamer->EmitLabel(StartSym); + Asm.OutStreamer->emitLabel(StartSym); } void DwarfStringPool::emit(AsmPrinter &Asm, MCSection *StrSection, @@ -100,7 +100,7 @@ void DwarfStringPool::emit(AsmPrinter &Asm, MCSection *StrSection, // Emit a label for reference from debug information entries. if (ShouldCreateSymbols) - Asm.OutStreamer->EmitLabel(Entry->getValue().Symbol); + Asm.OutStreamer->emitLabel(Entry->getValue().Symbol); // Emit the string itself with a terminating null byte. Asm.OutStreamer->AddComment("string offset=" + diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp index 8b15e26..433c9e2 100644 --- a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp @@ -1629,7 +1629,7 @@ void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) { MCSymbol *BeginLabel = Asm->createTempSymbol(Prefix + "start"); EndLabel = Asm->createTempSymbol(Prefix + "end"); Asm->emitLabelDifference(EndLabel, BeginLabel, 4); - Asm->OutStreamer->EmitLabel(BeginLabel); + Asm->OutStreamer->emitLabel(BeginLabel); } else Asm->emitInt32(getHeaderSize() + getUnitDie().getSize()); diff --git a/llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp b/llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp index 4d19a49..99ee456 100644 --- a/llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/EHStreamer.cpp @@ -432,8 +432,8 @@ MCSymbol *EHStreamer::emitExceptionTable() { MCSymbol *GCCETSym = Asm->OutContext.getOrCreateSymbol(Twine("GCC_except_table")+ Twine(Asm->getFunctionNumber())); - Asm->OutStreamer->EmitLabel(GCCETSym); - Asm->OutStreamer->EmitLabel(Asm->getCurExceptionSym()); + Asm->OutStreamer->emitLabel(GCCETSym); + Asm->OutStreamer->emitLabel(Asm->getCurExceptionSym()); // Emit the LSDA header. Asm->emitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart"); @@ -448,7 +448,7 @@ MCSymbol *EHStreamer::emitExceptionTable() { MCSymbol *TTBaseRefLabel = Asm->createTempSymbol("ttbaseref"); TTBaseLabel = Asm->createTempSymbol("ttbase"); Asm->emitLabelDifferenceAsULEB128(TTBaseLabel, TTBaseRefLabel); - Asm->OutStreamer->EmitLabel(TTBaseRefLabel); + Asm->OutStreamer->emitLabel(TTBaseRefLabel); } bool VerboseAsm = Asm->OutStreamer->isVerboseAsm(); @@ -458,7 +458,7 @@ MCSymbol *EHStreamer::emitExceptionTable() { MCSymbol *CstEndLabel = Asm->createTempSymbol("cst_end"); Asm->emitEncodingByte(CallSiteEncoding, "Call site"); Asm->emitLabelDifferenceAsULEB128(CstEndLabel, CstBeginLabel); - Asm->OutStreamer->EmitLabel(CstBeginLabel); + Asm->OutStreamer->emitLabel(CstBeginLabel); // SjLj / Wasm Exception handling if (IsSJLJ || IsWasm) { @@ -557,7 +557,7 @@ MCSymbol *EHStreamer::emitExceptionTable() { Asm->emitULEB128(S.Action); } } - Asm->OutStreamer->EmitLabel(CstEndLabel); + Asm->OutStreamer->emitLabel(CstEndLabel); // Emit the Action Table. int Entry = 0; @@ -632,7 +632,7 @@ void EHStreamer::emitTypeInfos(unsigned TTypeEncoding, MCSymbol *TTBaseLabel) { Asm->emitTTypeReference(GV, TTypeEncoding); } - Asm->OutStreamer->EmitLabel(TTBaseLabel); + Asm->OutStreamer->emitLabel(TTBaseLabel); // Emit the Exception Specifications. if (VerboseAsm && !FilterIds.empty()) { diff --git a/llvm/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp index 6ccf9e5..d0c63fd 100644 --- a/llvm/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp @@ -67,7 +67,7 @@ static void EmitCamlGlobal(const Module &M, AsmPrinter &AP, const char *Id) { MCSymbol *Sym = AP.OutContext.getOrCreateSymbol(TmpStr); AP.OutStreamer->emitSymbolAttribute(Sym, MCSA_Global); - AP.OutStreamer->EmitLabel(Sym); + AP.OutStreamer->emitLabel(Sym); } void OcamlGCMetadataPrinter::beginAssembly(Module &M, GCModuleInfo &Info, @@ -164,7 +164,7 @@ void OcamlGCMetadataPrinter::finishAssembly(Module &M, GCModuleInfo &Info, Twine(LiveCount) + " >= 65536."); } - AP.OutStreamer->EmitSymbolValue(J->Label, IntPtrSize); + AP.OutStreamer->emitSymbolValue(J->Label, IntPtrSize); AP.emitInt16(FrameSize); AP.emitInt16(LiveCount); diff --git a/llvm/lib/CodeGen/AsmPrinter/WasmException.cpp b/llvm/lib/CodeGen/AsmPrinter/WasmException.cpp index 444b0ed..baef4d2 100644 --- a/llvm/lib/CodeGen/AsmPrinter/WasmException.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/WasmException.cpp @@ -27,7 +27,7 @@ void WasmException::endModule() { Mangler::getNameWithPrefix(NameStr, "__cpp_exception", Asm->getDataLayout()); if (Asm->OutContext.lookupSymbol(NameStr)) { MCSymbol *ExceptionSym = Asm->GetExternalSymbolSymbol("__cpp_exception"); - Asm->OutStreamer->EmitLabel(ExceptionSym); + Asm->OutStreamer->emitLabel(ExceptionSym); } } @@ -58,7 +58,7 @@ void WasmException::endFunction(const MachineFunction *MF) { // end marker and set the size as the difference between the start end the end // marker. MCSymbol *LSDAEndLabel = Asm->createTempSymbol("GCC_except_table_end"); - Asm->OutStreamer->EmitLabel(LSDAEndLabel); + Asm->OutStreamer->emitLabel(LSDAEndLabel); MCContext &OutContext = Asm->OutStreamer->getContext(); const MCExpr *SizeExp = MCBinaryExpr::createSub( MCSymbolRefExpr::create(LSDAEndLabel, OutContext), diff --git a/llvm/lib/CodeGen/AsmPrinter/WinException.cpp b/llvm/lib/CodeGen/AsmPrinter/WinException.cpp index 6289820..18d3fd7 100644 --- a/llvm/lib/CodeGen/AsmPrinter/WinException.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/WinException.cpp @@ -207,7 +207,7 @@ void WinException::beginFunclet(const MachineBasicBlock &MBB, &F); // Now that we've emitted the alignment directive, point at our funclet. - Asm->OutStreamer->EmitLabel(Sym); + Asm->OutStreamer->emitLabel(Sym); } // Mark 'Sym' as starting our funclet. @@ -581,7 +581,7 @@ void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) { AddComment("Number of call sites"); OS.EmitValue(EntryCount, 4); - OS.EmitLabel(TableBegin); + OS.emitLabel(TableBegin); // Iterate over all the invoke try ranges. Unlike MSVC, LLVM currently only // models exceptions from invokes. LLVM also allows arbitrary reordering of @@ -609,7 +609,7 @@ void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) { LastEHState = StateChange.NewState; } - OS.EmitLabel(TableEnd); + OS.emitLabel(TableEnd); } void WinException::emitSEHActionsForRange(const WinEHFuncInfo &FuncInfo, @@ -713,8 +713,8 @@ void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) { // EHFlags & 1 -> Synchronous exceptions only, no async exceptions. // EHFlags & 2 -> ??? // EHFlags & 4 -> The function is noexcept(true), unwinding can't continue. - OS.EmitValueToAlignment(4); - OS.EmitLabel(FuncInfoXData); + OS.emitValueToAlignment(4); + OS.emitLabel(FuncInfoXData); AddComment("MagicNumber"); OS.EmitIntValue(0x19930522, 4); @@ -753,7 +753,7 @@ void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) { // void (*Action)(); // }; if (UnwindMapXData) { - OS.EmitLabel(UnwindMapXData); + OS.emitLabel(UnwindMapXData); for (const CxxUnwindMapEntry &UME : FuncInfo.CxxUnwindMap) { MCSymbol *CleanupSym = getMCSymbolForMBB(Asm, UME.Cleanup.dyn_cast()); @@ -773,7 +773,7 @@ void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) { // HandlerType *HandlerArray; // }; if (TryBlockMapXData) { - OS.EmitLabel(TryBlockMapXData); + OS.emitLabel(TryBlockMapXData); SmallVector HandlerMaps; for (size_t I = 0, E = FuncInfo.TryBlockMap.size(); I != E; ++I) { const WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I]; @@ -829,7 +829,7 @@ void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) { // void (*Handler)(); // int32_t ParentFrameOffset; // x64 and AArch64 only // }; - OS.EmitLabel(HandlerMapXData); + OS.emitLabel(HandlerMapXData); for (const WinEHHandlerType &HT : TBME.HandlerArray) { // Get the frame escape label with the offset of the catch object. If // the index is INT_MAX, then there is no catch object, and we should @@ -871,7 +871,7 @@ void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) { // int32_t State; // }; if (IPToStateXData) { - OS.EmitLabel(IPToStateXData); + OS.emitLabel(IPToStateXData); for (auto &IPStatePair : IPToStateTable) { AddComment("IP"); OS.EmitValue(IPStatePair.first, 4); @@ -979,8 +979,8 @@ void WinException::emitExceptHandlerTable(const MachineFunction *MF) { // Emit the __ehtable label that we use for llvm.x86.seh.lsda. MCSymbol *LSDALabel = Asm->OutContext.getOrCreateLSDASymbol(FLinkageName); - OS.EmitValueToAlignment(4); - OS.EmitLabel(LSDALabel); + OS.emitValueToAlignment(4); + OS.emitLabel(LSDALabel); const auto *Per = cast(F.getPersonalityFn()->stripPointerCasts()); StringRef PerName = Per->getName(); diff --git a/llvm/lib/CodeGen/FaultMaps.cpp b/llvm/lib/CodeGen/FaultMaps.cpp index de0b4fa..e9b3641 100644 --- a/llvm/lib/CodeGen/FaultMaps.cpp +++ b/llvm/lib/CodeGen/FaultMaps.cpp @@ -57,7 +57,7 @@ void FaultMaps::serializeToFaultMapSection() { OS.SwitchSection(FaultMapSection); // Emit a dummy symbol to force section inclusion. - OS.EmitLabel(OutContext.getOrCreateSymbol(Twine("__LLVM_FaultMaps"))); + OS.emitLabel(OutContext.getOrCreateSymbol(Twine("__LLVM_FaultMaps"))); LLVM_DEBUG(dbgs() << "********** Fault Map Output **********\n"); @@ -80,7 +80,7 @@ void FaultMaps::emitFunctionInfo(const MCSymbol *FnLabel, MCStreamer &OS = *AP.OutStreamer; LLVM_DEBUG(dbgs() << WFMP << " function addr: " << *FnLabel << "\n"); - OS.EmitSymbolValue(FnLabel, 8); + OS.emitSymbolValue(FnLabel, 8); LLVM_DEBUG(dbgs() << WFMP << " #faulting PCs: " << FFI.size() << "\n"); OS.EmitIntValue(FFI.size(), 4); diff --git a/llvm/lib/CodeGen/StackMaps.cpp b/llvm/lib/CodeGen/StackMaps.cpp index e16587c..a016df0 100644 --- a/llvm/lib/CodeGen/StackMaps.cpp +++ b/llvm/lib/CodeGen/StackMaps.cpp @@ -442,7 +442,7 @@ void StackMaps::emitFunctionFrameRecords(MCStreamer &OS) { LLVM_DEBUG(dbgs() << WSMP << "function addr: " << FR.first << " frame size: " << FR.second.StackSize << " callsite count: " << FR.second.RecordCount << '\n'); - OS.EmitSymbolValue(FR.first, 8); + OS.emitSymbolValue(FR.first, 8); OS.EmitIntValue(FR.second.StackSize, 8); OS.EmitIntValue(FR.second.RecordCount, 8); } @@ -528,7 +528,7 @@ void StackMaps::emitCallsiteEntries(MCStreamer &OS) { } // Emit alignment to 8 byte. - OS.EmitValueToAlignment(8); + OS.emitValueToAlignment(8); // Num live-out registers and padding to align to 4 byte. OS.EmitIntValue(0, 2); @@ -540,7 +540,7 @@ void StackMaps::emitCallsiteEntries(MCStreamer &OS) { OS.EmitIntValue(LO.Size, 1); } // Emit alignment to 8 byte. - OS.EmitValueToAlignment(8); + OS.emitValueToAlignment(8); } } @@ -564,7 +564,7 @@ void StackMaps::serializeToStackMapSection() { OS.SwitchSection(StackMapSection); // Emit a dummy symbol to force section inclusion. - OS.EmitLabel(OutContext.getOrCreateSymbol(Twine("__LLVM_StackMaps"))); + OS.emitLabel(OutContext.getOrCreateSymbol(Twine("__LLVM_StackMaps"))); // Serialize data. LLVM_DEBUG(dbgs() << "********** Stack Map Output **********\n"); diff --git a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp index b38ebd1..fe3e086 100644 --- a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp +++ b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp @@ -304,7 +304,7 @@ void TargetLoweringObjectFileELF::emitModuleMetadata(MCStreamer &Streamer, if (!Section.empty()) { auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC); Streamer.SwitchSection(S); - Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO"))); + Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO"))); Streamer.EmitIntValue(Version, 4); Streamer.EmitIntValue(Flags, 4); Streamer.AddBlankLine(); @@ -377,13 +377,13 @@ void TargetLoweringObjectFileELF::emitPersonalityValue( ELF::SHT_PROGBITS, Flags, 0); unsigned Size = DL.getPointerSize(); Streamer.SwitchSection(Sec); - Streamer.EmitValueToAlignment(DL.getPointerABIAlignment(0).value()); + Streamer.emitValueToAlignment(DL.getPointerABIAlignment(0).value()); Streamer.emitSymbolAttribute(Label, MCSA_ELF_TypeObject); const MCExpr *E = MCConstantExpr::create(Size, getContext()); Streamer.emitELFSize(Label, E); - Streamer.EmitLabel(Label); + Streamer.emitLabel(Label); - Streamer.EmitSymbolValue(Sym, Size); + Streamer.emitSymbolValue(Sym, Size); } const MCExpr *TargetLoweringObjectFileELF::getTTypeGlobalReference( @@ -918,7 +918,7 @@ void TargetLoweringObjectFileMachO::emitModuleMetadata(MCStreamer &Streamer, MCSectionMachO *S = getContext().getMachOSection( Segment, Section, TAA, StubSize, SectionKind::getData()); Streamer.SwitchSection(S); - Streamer.EmitLabel(getContext(). + Streamer.emitLabel(getContext(). getOrCreateSymbol(StringRef("L_OBJC_IMAGE_INFO"))); Streamer.EmitIntValue(VersionVal, 4); Streamer.EmitIntValue(ImageInfoFlags, 4); @@ -1472,7 +1472,7 @@ void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer, Section, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ, SectionKind::getReadOnly()); Streamer.SwitchSection(S); - Streamer.EmitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO"))); + Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO"))); Streamer.EmitIntValue(Version, 4); Streamer.EmitIntValue(Flags, 4); Streamer.AddBlankLine(); diff --git a/llvm/lib/MC/ConstantPools.cpp b/llvm/lib/MC/ConstantPools.cpp index eb98014..a7e31ac 100644 --- a/llvm/lib/MC/ConstantPools.cpp +++ b/llvm/lib/MC/ConstantPools.cpp @@ -28,8 +28,8 @@ void ConstantPool::emitEntries(MCStreamer &Streamer) { return; Streamer.emitDataRegion(MCDR_DataRegion); for (const ConstantPoolEntry &Entry : Entries) { - Streamer.EmitCodeAlignment(Entry.Size); // align naturally - Streamer.EmitLabel(Entry.Label); + Streamer.emitCodeAlignment(Entry.Size); // align naturally + Streamer.emitLabel(Entry.Label); Streamer.EmitValue(Entry.Value, Entry.Size, Entry.Loc); } Streamer.emitDataRegion(MCDR_DataRegionEnd); diff --git a/llvm/lib/MC/MCAsmInfo.cpp b/llvm/lib/MC/MCAsmInfo.cpp index 420dbaa..41f27db 100644 --- a/llvm/lib/MC/MCAsmInfo.cpp +++ b/llvm/lib/MC/MCAsmInfo.cpp @@ -95,7 +95,7 @@ MCAsmInfo::getExprForFDESymbol(const MCSymbol *Sym, MCContext &Context = Streamer.getContext(); const MCExpr *Res = MCSymbolRefExpr::create(Sym, Context); MCSymbol *PCSym = Context.createTempSymbol(); - Streamer.EmitLabel(PCSym); + Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, Context); return MCBinaryExpr::createSub(Res, PC, Context); } diff --git a/llvm/lib/MC/MCAsmStreamer.cpp b/llvm/lib/MC/MCAsmStreamer.cpp index 75d5df8..f8972cf 100644 --- a/llvm/lib/MC/MCAsmStreamer.cpp +++ b/llvm/lib/MC/MCAsmStreamer.cpp @@ -141,7 +141,7 @@ public: const MCSymbol *Aliasee) override; void emitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override; - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; void emitAssemblerFlag(MCAssemblerFlag Flag) override; void emitLinkerOptions(ArrayRef Options) override; @@ -192,7 +192,7 @@ public: void emitBytes(StringRef Data) override; - void EmitValueImpl(const MCExpr *Value, unsigned Size, + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc()) override; void EmitIntValue(uint64_t Value, unsigned Size) override; void EmitIntValueInHex(uint64_t Value, unsigned Size) override; @@ -202,14 +202,14 @@ public: void emitSLEB128Value(const MCExpr *Value) override; - void EmitDTPRel32Value(const MCExpr *Value) override; - void EmitDTPRel64Value(const MCExpr *Value) override; - void EmitTPRel32Value(const MCExpr *Value) override; - void EmitTPRel64Value(const MCExpr *Value) override; + void emitDTPRel32Value(const MCExpr *Value) override; + void emitDTPRel64Value(const MCExpr *Value) override; + void emitTPRel32Value(const MCExpr *Value) override; + void emitTPRel64Value(const MCExpr *Value) override; - void EmitGPRel64Value(const MCExpr *Value) override; + void emitGPRel64Value(const MCExpr *Value) override; - void EmitGPRel32Value(const MCExpr *Value) override; + void emitGPRel32Value(const MCExpr *Value) override; void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc = SMLoc()) override; @@ -217,11 +217,11 @@ public: void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr, SMLoc Loc = SMLoc()) override; - void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, + void emitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, unsigned ValueSize = 1, unsigned MaxBytesToEmit = 0) override; - void EmitCodeAlignment(unsigned ByteAlignment, + void emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit = 0) override; void emitValueToOffset(const MCExpr *Offset, @@ -464,8 +464,8 @@ void MCAsmStreamer::emitELFSymverDirective(StringRef AliasName, EmitEOL(); } -void MCAsmStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { - MCStreamer::EmitLabel(Symbol, Loc); +void MCAsmStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { + MCStreamer::emitLabel(Symbol, Loc); Symbol->print(OS, MAI); OS << MAI->getLabelSuffix(); @@ -979,7 +979,7 @@ void MCAsmStreamer::EmitIntValueInHexWithPadding(uint64_t Value, EmitValue(MCConstantExpr::create(Value, getContext(), true, Size), Size); } -void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, +void MCAsmStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { assert(Size <= 8 && "Invalid size"); assert(getCurrentSectionOnly() && @@ -1059,42 +1059,42 @@ void MCAsmStreamer::emitSLEB128Value(const MCExpr *Value) { EmitEOL(); } -void MCAsmStreamer::EmitDTPRel64Value(const MCExpr *Value) { +void MCAsmStreamer::emitDTPRel64Value(const MCExpr *Value) { assert(MAI->getDTPRel64Directive() != nullptr); OS << MAI->getDTPRel64Directive(); Value->print(OS, MAI); EmitEOL(); } -void MCAsmStreamer::EmitDTPRel32Value(const MCExpr *Value) { +void MCAsmStreamer::emitDTPRel32Value(const MCExpr *Value) { assert(MAI->getDTPRel32Directive() != nullptr); OS << MAI->getDTPRel32Directive(); Value->print(OS, MAI); EmitEOL(); } -void MCAsmStreamer::EmitTPRel64Value(const MCExpr *Value) { +void MCAsmStreamer::emitTPRel64Value(const MCExpr *Value) { assert(MAI->getTPRel64Directive() != nullptr); OS << MAI->getTPRel64Directive(); Value->print(OS, MAI); EmitEOL(); } -void MCAsmStreamer::EmitTPRel32Value(const MCExpr *Value) { +void MCAsmStreamer::emitTPRel32Value(const MCExpr *Value) { assert(MAI->getTPRel32Directive() != nullptr); OS << MAI->getTPRel32Directive(); Value->print(OS, MAI); EmitEOL(); } -void MCAsmStreamer::EmitGPRel64Value(const MCExpr *Value) { +void MCAsmStreamer::emitGPRel64Value(const MCExpr *Value) { assert(MAI->getGPRel64Directive() != nullptr); OS << MAI->getGPRel64Directive(); Value->print(OS, MAI); EmitEOL(); } -void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) { +void MCAsmStreamer::emitGPRel32Value(const MCExpr *Value) { assert(MAI->getGPRel32Directive() != nullptr); OS << MAI->getGPRel32Directive(); Value->print(OS, MAI); @@ -1141,7 +1141,7 @@ void MCAsmStreamer::emitFill(const MCExpr &NumValues, int64_t Size, EmitEOL(); } -void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, +void MCAsmStreamer::emitValueToAlignment(unsigned ByteAlignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit) { if (MAI->useDotAlignForAlignment()) { @@ -1203,10 +1203,10 @@ void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, EmitEOL(); } -void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment, +void MCAsmStreamer::emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit) { // Emit with a text fill value. - EmitValueToAlignment(ByteAlignment, MAI->getTextAlignFillValue(), + emitValueToAlignment(ByteAlignment, MAI->getTextAlignFillValue(), 1, MaxBytesToEmit); } @@ -2038,7 +2038,7 @@ void MCAsmStreamer::FinishImpl() { assert(Tables.size() == 1 && "asm output only supports one line table"); if (auto *Label = Tables.begin()->second.getLabel()) { SwitchSection(getContext().getObjectFileInfo()->getDwarfLineSection()); - EmitLabel(Label); + emitLabel(Label); } } } diff --git a/llvm/lib/MC/MCCodeView.cpp b/llvm/lib/MC/MCCodeView.cpp index 319259e..66b1b14 100644 --- a/llvm/lib/MC/MCCodeView.cpp +++ b/llvm/lib/MC/MCCodeView.cpp @@ -174,7 +174,7 @@ void CodeViewContext::emitStringTable(MCObjectStreamer &OS) { OS.EmitIntValue(unsigned(DebugSubsectionKind::StringTable), 4); OS.emitAbsoluteSymbolDiff(StringEnd, StringBegin, 4); - OS.EmitLabel(StringBegin); + OS.emitLabel(StringBegin); // Put the string table data fragment here, if we haven't already put it // somewhere else. If somebody wants two string tables in their .s file, one @@ -184,9 +184,9 @@ void CodeViewContext::emitStringTable(MCObjectStreamer &OS) { InsertedStrTabFragment = true; } - OS.EmitValueToAlignment(4, 0); + OS.emitValueToAlignment(4, 0); - OS.EmitLabel(StringEnd); + OS.emitLabel(StringEnd); } void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) { @@ -201,7 +201,7 @@ void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) { OS.EmitIntValue(unsigned(DebugSubsectionKind::FileChecksums), 4); OS.emitAbsoluteSymbolDiff(FileEnd, FileBegin, 4); - OS.EmitLabel(FileBegin); + OS.emitLabel(FileBegin); unsigned CurrentOffset = 0; @@ -232,10 +232,10 @@ void CodeViewContext::emitFileChecksums(MCObjectStreamer &OS) { OS.EmitIntValue(static_cast(File.Checksum.size()), 1); OS.EmitIntValue(File.ChecksumKind, 1); OS.emitBytes(toStringRef(File.Checksum)); - OS.EmitValueToAlignment(4); + OS.emitValueToAlignment(4); } - OS.EmitLabel(FileEnd); + OS.emitLabel(FileEnd); ChecksumOffsetsAssigned = true; } @@ -252,14 +252,14 @@ void CodeViewContext::emitFileChecksumOffset(MCObjectStreamer &OS, Files.resize(Idx + 1); if (ChecksumOffsetsAssigned) { - OS.EmitSymbolValue(Files[Idx].ChecksumTableOffset, 4); + OS.emitSymbolValue(Files[Idx].ChecksumTableOffset, 4); return; } const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(Files[Idx].ChecksumTableOffset, OS.getContext()); - OS.EmitValueImpl(SRE, 4); + OS.emitValueImpl(SRE, 4); } void CodeViewContext::addLineEntry(const MCCVLoc &LineEntry) { @@ -333,7 +333,7 @@ void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS, OS.EmitIntValue(unsigned(DebugSubsectionKind::Lines), 4); OS.emitAbsoluteSymbolDiff(LineEnd, LineBegin, 4); - OS.EmitLabel(LineBegin); + OS.emitLabel(LineBegin); OS.EmitCOFFSecRel32(FuncBegin, /*Offset=*/0); OS.EmitCOFFSectionIndex(FuncBegin); @@ -381,7 +381,7 @@ void CodeViewContext::emitLineTableForFunction(MCObjectStreamer &OS, } I = FileSegEnd; } - OS.EmitLabel(LineEnd); + OS.emitLabel(LineEnd); } static bool compressAnnotation(uint32_t Data, SmallVectorImpl &Buffer) { diff --git a/llvm/lib/MC/MCDwarf.cpp b/llvm/lib/MC/MCDwarf.cpp index 7b8bdce..9417a04 100644 --- a/llvm/lib/MC/MCDwarf.cpp +++ b/llvm/lib/MC/MCDwarf.cpp @@ -91,7 +91,7 @@ void MCDwarfLineEntry::Make(MCObjectStreamer *MCOS, MCSection *Section) { // Create a symbol at in the current section for use in the line entry. MCSymbol *LineSym = MCOS->getContext().createTempSymbol(); // Set the value of the symbol to use for the MCDwarfLineEntry. - MCOS->EmitLabel(LineSym); + MCOS->emitLabel(LineSym); // Get the current .loc info saved in the context. const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc(); @@ -263,7 +263,7 @@ void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params, return; Optional NoLineStr(None); MCOS.SwitchSection(Section); - MCOS.EmitLabel(Header.Emit(&MCOS, Params, None, NoLineStr).second); + MCOS.emitLabel(Header.Emit(&MCOS, Params, None, NoLineStr).second); } std::pair @@ -455,7 +455,7 @@ MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params, if (!LineStartSym) LineStartSym = context.createTempSymbol(); // Set the value of the symbol, as we are at the start of the line table. - MCOS->EmitLabel(LineStartSym); + MCOS->emitLabel(LineStartSym); // Create a symbol for the end of the section (to be set when we get there). MCSymbol *LineEndSym = context.createTempSymbol(); @@ -515,7 +515,7 @@ MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params, // This is the end of the prologue, so set the value of the symbol at the // end of the prologue (that was used in a previous expression). - MCOS->EmitLabel(ProEndSym); + MCOS->emitLabel(ProEndSym); return std::make_pair(LineStartSym, LineEndSym); } @@ -531,7 +531,7 @@ void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS, // This is the end of the section, so set the value of the symbol at the end // of this section (that was used in a previous expression). - MCOS->EmitLabel(LineEndSym); + MCOS->emitLabel(LineEndSym); } Expected MCDwarfLineTable::tryGetFile(StringRef &Directory, @@ -886,7 +886,7 @@ static void EmitGenDwarfAranges(MCStreamer *MCOS, // The 4 byte offset to the compile unit in the .debug_info from the start // of the .debug_info. if (InfoSectionSymbol) - MCOS->EmitSymbolValue(InfoSectionSymbol, 4, + MCOS->emitSymbolValue(InfoSectionSymbol, 4, asmInfo->needsDwarfSectionOffsetDirective()); else MCOS->EmitIntValue(0, 4); @@ -933,7 +933,7 @@ static void EmitGenDwarfInfo(MCStreamer *MCOS, // Create a symbol at the start and end of this section used in here for the // expression to calculate the length in the header. MCSymbol *InfoStart = context.createTempSymbol(); - MCOS->EmitLabel(InfoStart); + MCOS->emitLabel(InfoStart); MCSymbol *InfoEnd = context.createTempSymbol(); // First part: the header. @@ -959,7 +959,7 @@ static void EmitGenDwarfInfo(MCStreamer *MCOS, if (AbbrevSectionSymbol == nullptr) MCOS->EmitIntValue(0, 4); else - MCOS->EmitSymbolValue(AbbrevSectionSymbol, 4, + MCOS->emitSymbolValue(AbbrevSectionSymbol, 4, AsmInfo.needsDwarfSectionOffsetDirective()); if (context.getDwarfVersion() <= 4) MCOS->EmitIntValue(AddrSize, 1); @@ -972,7 +972,7 @@ static void EmitGenDwarfInfo(MCStreamer *MCOS, // DW_AT_stmt_list, a 4 byte offset from the start of the .debug_line section, // which is at the start of that section so this is zero. if (LineSectionSymbol) - MCOS->EmitSymbolValue(LineSectionSymbol, 4, + MCOS->emitSymbolValue(LineSectionSymbol, 4, AsmInfo.needsDwarfSectionOffsetDirective()); else MCOS->EmitIntValue(0, 4); @@ -983,7 +983,7 @@ static void EmitGenDwarfInfo(MCStreamer *MCOS, // AT_ranges, the 4 byte offset from the start of the .debug_ranges section // to the address range list for this compilation unit. - MCOS->EmitSymbolValue(RangesSectionSymbol, 4); + MCOS->emitSymbolValue(RangesSectionSymbol, 4); } else { // If we only have one non-empty code section, we can use the simpler // AT_low_pc and AT_high_pc attributes. @@ -1090,7 +1090,7 @@ static void EmitGenDwarfInfo(MCStreamer *MCOS, MCOS->EmitIntValue(0, 1); // Now set the value of the symbol at the end of the info section. - MCOS->EmitLabel(InfoEnd); + MCOS->emitLabel(InfoEnd); } // When generating dwarf for assembly source files this emits the data for @@ -1165,18 +1165,18 @@ void MCGenDwarfInfo::Emit(MCStreamer *MCOS) { MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfInfoSection()); if (CreateDwarfSectionSymbols) { InfoSectionSymbol = context.createTempSymbol(); - MCOS->EmitLabel(InfoSectionSymbol); + MCOS->emitLabel(InfoSectionSymbol); } MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfAbbrevSection()); if (CreateDwarfSectionSymbols) { AbbrevSectionSymbol = context.createTempSymbol(); - MCOS->EmitLabel(AbbrevSectionSymbol); + MCOS->emitLabel(AbbrevSectionSymbol); } if (UseRangesSection) { MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection()); if (CreateDwarfSectionSymbols) { RangesSectionSymbol = context.createTempSymbol(); - MCOS->EmitLabel(RangesSectionSymbol); + MCOS->emitLabel(RangesSectionSymbol); } } @@ -1234,7 +1234,7 @@ void MCGenDwarfLabelEntry::Make(MCSymbol *Symbol, MCStreamer *MCOS, // original symbol. So when used they won't get a low bit set after // relocation. MCSymbol *Label = context.createTempSymbol(); - MCOS->EmitLabel(Label); + MCOS->emitLabel(Label); // Create and entry for the info and add it to the other entries. MCOS->getContext().addMCGenDwarfLabelEntry( @@ -1516,7 +1516,7 @@ void FrameEmitterImpl::EmitCompactUnwind(const MCDwarfFrameInfo &Frame) { // Range Start unsigned FDEEncoding = MOFI->getFDEEncoding(); unsigned Size = getSizeForEncoding(Streamer, FDEEncoding); - Streamer.EmitSymbolValue(Frame.Begin, Size); + Streamer.emitSymbolValue(Frame.Begin, Size); // Range Length const MCExpr *Range = MakeStartMinusEndExpr(Streamer, *Frame.Begin, @@ -1530,14 +1530,14 @@ void FrameEmitterImpl::EmitCompactUnwind(const MCDwarfFrameInfo &Frame) { // Personality Function Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr); if (!DwarfEHFrameOnly && Frame.Personality) - Streamer.EmitSymbolValue(Frame.Personality, Size); + Streamer.emitSymbolValue(Frame.Personality, Size); else Streamer.EmitIntValue(0, Size); // No personality fn // LSDA Size = getSizeForEncoding(Streamer, Frame.LsdaEncoding); if (!DwarfEHFrameOnly && Frame.Lsda) - Streamer.EmitSymbolValue(Frame.Lsda, Size); + Streamer.emitSymbolValue(Frame.Lsda, Size); else Streamer.EmitIntValue(0, Size); // No LSDA } @@ -1563,7 +1563,7 @@ const MCSymbol &FrameEmitterImpl::EmitCIE(const MCDwarfFrameInfo &Frame) { const MCObjectFileInfo *MOFI = context.getObjectFileInfo(); MCSymbol *sectionStart = context.createTempSymbol(); - Streamer.EmitLabel(sectionStart); + Streamer.emitLabel(sectionStart); MCSymbol *sectionEnd = context.createTempSymbol(); @@ -1667,9 +1667,9 @@ const MCSymbol &FrameEmitterImpl::EmitCIE(const MCDwarfFrameInfo &Frame) { InitialCFAOffset = CFAOffset; // Padding - Streamer.EmitValueToAlignment(IsEH ? 4 : MAI->getCodePointerSize()); + Streamer.emitValueToAlignment(IsEH ? 4 : MAI->getCodePointerSize()); - Streamer.EmitLabel(sectionEnd); + Streamer.emitLabel(sectionEnd); return *sectionStart; } @@ -1688,7 +1688,7 @@ void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart, const MCExpr *Length = MakeStartMinusEndExpr(Streamer, *fdeStart, *fdeEnd, 0); emitAbsValue(Streamer, Length, 4); - Streamer.EmitLabel(fdeStart); + Streamer.emitLabel(fdeStart); // CIE Pointer const MCAsmInfo *asmInfo = context.getAsmInfo(); @@ -1701,7 +1701,7 @@ void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart, MakeStartMinusEndExpr(Streamer, SectionStart, cieStart, 0); emitAbsValue(Streamer, offset, 4); } else { - Streamer.EmitSymbolValue(&cieStart, 4, + Streamer.emitSymbolValue(&cieStart, 4, asmInfo->needsDwarfSectionOffsetDirective()); } @@ -1738,9 +1738,9 @@ void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart, // since a null CIE is interpreted as the end. Old systems overaligned // .eh_frame, so we do too and account for it in the last FDE. unsigned Align = LastInSection ? asmInfo->getCodePointerSize() : PCSize; - Streamer.EmitValueToAlignment(Align); + Streamer.emitValueToAlignment(Align); - Streamer.EmitLabel(fdeEnd); + Streamer.emitLabel(fdeEnd); } namespace { @@ -1837,7 +1837,7 @@ void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB, if (Frame.CompactUnwindEncoding == 0) continue; if (!SectionEmitted) { Streamer.SwitchSection(MOFI->getCompactUnwindSection()); - Streamer.EmitValueToAlignment(AsmInfo->getCodePointerSize()); + Streamer.emitValueToAlignment(AsmInfo->getCodePointerSize()); SectionEmitted = true; } NeedsEHFrameSection |= @@ -1855,7 +1855,7 @@ void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB, Streamer.SwitchSection(&Section); MCSymbol *SectionStart = Context.createTempSymbol(); - Streamer.EmitLabel(SectionStart); + Streamer.emitLabel(SectionStart); DenseMap CIEStarts; diff --git a/llvm/lib/MC/MCELFStreamer.cpp b/llvm/lib/MC/MCELFStreamer.cpp index 05e79f7..131c1bb 100644 --- a/llvm/lib/MC/MCELFStreamer.cpp +++ b/llvm/lib/MC/MCELFStreamer.cpp @@ -90,15 +90,15 @@ void MCELFStreamer::mergeFragment(MCDataFragment *DF, void MCELFStreamer::InitSections(bool NoExecStack) { MCContext &Ctx = getContext(); SwitchSection(Ctx.getObjectFileInfo()->getTextSection()); - EmitCodeAlignment(4); + emitCodeAlignment(4); if (NoExecStack) SwitchSection(Ctx.getAsmInfo()->getNonexecutableStackSection(Ctx)); } -void MCELFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc) { +void MCELFStreamer::emitLabel(MCSymbol *S, SMLoc Loc) { auto *Symbol = cast(S); - MCObjectStreamer::EmitLabel(Symbol, Loc); + MCObjectStreamer::emitLabel(Symbol, Loc); const MCSectionELF &Section = static_cast(*getCurrentSectionOnly()); @@ -304,8 +304,8 @@ void MCELFStreamer::emitCommonSymbol(MCSymbol *S, uint64_t Size, MCSectionSubPair P = getCurrentSection(); SwitchSection(&Section); - EmitValueToAlignment(ByteAlignment, 0, 1, 0); - EmitLabel(Symbol); + emitValueToAlignment(ByteAlignment, 0, 1, 0); + emitLabel(Symbol); EmitZeros(Size); SwitchSection(P.first, P.second); @@ -338,21 +338,21 @@ void MCELFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size, emitCommonSymbol(Symbol, Size, ByteAlignment); } -void MCELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, +void MCELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { if (isBundleLocked()) report_fatal_error("Emitting values inside a locked bundle is forbidden"); fixSymbolsInTLSFixups(Value); - MCObjectStreamer::EmitValueImpl(Value, Size, Loc); + MCObjectStreamer::emitValueImpl(Value, Size, Loc); } -void MCELFStreamer::EmitValueToAlignment(unsigned ByteAlignment, +void MCELFStreamer::emitValueToAlignment(unsigned ByteAlignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit) { if (isBundleLocked()) report_fatal_error("Emitting values inside a locked bundle is forbidden"); - MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value, + MCObjectStreamer::emitValueToAlignment(ByteAlignment, Value, ValueSize, MaxBytesToEmit); } diff --git a/llvm/lib/MC/MCMachOStreamer.cpp b/llvm/lib/MC/MCMachOStreamer.cpp index aa506c3..d8bebe1 100644 --- a/llvm/lib/MC/MCMachOStreamer.cpp +++ b/llvm/lib/MC/MCMachOStreamer.cpp @@ -82,7 +82,7 @@ public: /// @{ void ChangeSection(MCSection *Sect, const MCExpr *Subsect) override; - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override; void emitEHSymAttributes(const MCSymbol *Symbol, MCSymbol *EHSymbol) override; void emitAssemblerFlag(MCAssemblerFlag Flag) override; @@ -178,13 +178,13 @@ void MCMachOStreamer::emitEHSymAttributes(const MCSymbol *Symbol, emitSymbolAttribute(EHSymbol, MCSA_PrivateExtern); } -void MCMachOStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { +void MCMachOStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { // We have to create a new fragment if this is an atom defining symbol, // fragments cannot span atoms. if (getAssembler().isSymbolLinkerVisible(*Symbol)) insert(new MCDataFragment()); - MCObjectStreamer::EmitLabel(Symbol, Loc); + MCObjectStreamer::emitLabel(Symbol, Loc); // This causes the reference type flag to be cleared. Darwin 'as' was "trying" // to clear the weak reference and weak definition bits too, but the @@ -212,7 +212,7 @@ void MCMachOStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) { void MCMachOStreamer::emitDataRegion(DataRegionData::KindTy Kind) { // Create a temporary label to mark the start of the data region. MCSymbol *Start = getContext().createTempSymbol(); - EmitLabel(Start); + emitLabel(Start); // Record the region for the object writer to use. DataRegionData Data = { Kind, Start, nullptr }; std::vector &Regions = getAssembler().getDataRegions(); @@ -226,7 +226,7 @@ void MCMachOStreamer::emitDataRegionEnd() { assert(!Data.End && "Mismatched .end_data_region!"); // Create a temporary label to mark the end of the data region. Data.End = getContext().createTempSymbol(); - EmitLabel(Data.End); + emitLabel(Data.End); } void MCMachOStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) { @@ -438,8 +438,8 @@ void MCMachOStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol, // The symbol may not be present, which only creates the section. if (Symbol) { - EmitValueToAlignment(ByteAlignment, 0, 1, 0); - EmitLabel(Symbol); + emitValueToAlignment(ByteAlignment, 0, 1, 0); + emitLabel(Symbol); EmitZeros(Size); } PopSection(); diff --git a/llvm/lib/MC/MCNullStreamer.cpp b/llvm/lib/MC/MCNullStreamer.cpp index 4a522b8..0d12061 100644 --- a/llvm/lib/MC/MCNullStreamer.cpp +++ b/llvm/lib/MC/MCNullStreamer.cpp @@ -35,7 +35,7 @@ namespace { void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr, uint64_t Size = 0, unsigned ByteAlignment = 0, SMLoc Loc = SMLoc()) override {} - void EmitGPRel32Value(const MCExpr *Value) override {} + void emitGPRel32Value(const MCExpr *Value) override {} void BeginCOFFSymbolDef(const MCSymbol *Symbol) override {} void EmitCOFFSymbolStorageClass(int StorageClass) override {} void EmitCOFFSymbolType(int Type) override {} diff --git a/llvm/lib/MC/MCObjectStreamer.cpp b/llvm/lib/MC/MCObjectStreamer.cpp index 3781e60..a785ef3 100644 --- a/llvm/lib/MC/MCObjectStreamer.cpp +++ b/llvm/lib/MC/MCObjectStreamer.cpp @@ -225,9 +225,9 @@ void MCObjectStreamer::emitCFISections(bool EH, bool Debug) { EmitDebugFrame = Debug; } -void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, +void MCObjectStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { - MCStreamer::EmitValueImpl(Value, Size, Loc); + MCStreamer::emitValueImpl(Value, Size, Loc); MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); @@ -252,23 +252,23 @@ void MCObjectStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, MCSymbol *MCObjectStreamer::emitCFILabel() { MCSymbol *Label = getContext().createTempSymbol("cfi", true); - EmitLabel(Label); + emitLabel(Label); return Label; } void MCObjectStreamer::emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) { // We need to create a local symbol to avoid relocations. Frame.Begin = getContext().createTempSymbol(); - EmitLabel(Frame.Begin); + emitLabel(Frame.Begin); } void MCObjectStreamer::emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) { Frame.End = getContext().createTempSymbol(); - EmitLabel(Frame.End); + emitLabel(Frame.End); } -void MCObjectStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { - MCStreamer::EmitLabel(Symbol, Loc); +void MCObjectStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { + MCStreamer::emitLabel(Symbol, Loc); getAssembler().registerSymbol(*Symbol); @@ -295,7 +295,7 @@ void MCObjectStreamer::emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F, uint64_t Offset) { assert(F->getParent() == getCurrentSectionOnly()); - MCStreamer::EmitLabel(Symbol, Loc); + MCStreamer::emitLabel(Symbol, Loc); getAssembler().registerSymbol(*Symbol); auto *DF = dyn_cast_or_null(F); Symbol->setOffset(Offset); @@ -475,7 +475,7 @@ static void emitDwarfSetLineAddr(MCObjectStreamer &OS, OS.EmitIntValue(dwarf::DW_LNS_extended_op, 1); OS.emitULEB128IntValue(PointerSize + 1); OS.EmitIntValue(dwarf::DW_LNE_set_address, 1); - OS.EmitSymbolValue(Label, PointerSize); + OS.emitSymbolValue(Label, PointerSize); // emit the sequence for the LineDelta (from 1) and a zero address delta. MCDwarfLineAddr::Emit(&OS, Params, LineDelta, 0); @@ -521,7 +521,7 @@ void MCObjectStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, // Emit a label at the current position and record it in the CodeViewContext. MCSymbol *LineSym = getContext().createTempSymbol(); - EmitLabel(LineSym); + emitLabel(LineSym); getContext().getCVContext().recordCVLoc(getContext(), LineSym, FunctionId, FileNo, Line, Column, PrologueEnd, IsStmt); @@ -574,7 +574,7 @@ void MCObjectStreamer::emitBytes(StringRef Data) { DF->getContents().append(Data.begin(), Data.end()); } -void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment, +void MCObjectStreamer::emitValueToAlignment(unsigned ByteAlignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit) { @@ -588,9 +588,9 @@ void MCObjectStreamer::EmitValueToAlignment(unsigned ByteAlignment, CurSec->setAlignment(Align(ByteAlignment)); } -void MCObjectStreamer::EmitCodeAlignment(unsigned ByteAlignment, +void MCObjectStreamer::emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit) { - EmitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit); + emitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit); cast(getCurrentFragment())->setEmitNops(true); } @@ -601,7 +601,7 @@ void MCObjectStreamer::emitValueToOffset(const MCExpr *Offset, } // Associate DTPRel32 fixup with data and resize data area -void MCObjectStreamer::EmitDTPRel32Value(const MCExpr *Value) { +void MCObjectStreamer::emitDTPRel32Value(const MCExpr *Value) { MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); @@ -611,7 +611,7 @@ void MCObjectStreamer::EmitDTPRel32Value(const MCExpr *Value) { } // Associate DTPRel64 fixup with data and resize data area -void MCObjectStreamer::EmitDTPRel64Value(const MCExpr *Value) { +void MCObjectStreamer::emitDTPRel64Value(const MCExpr *Value) { MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); @@ -621,7 +621,7 @@ void MCObjectStreamer::EmitDTPRel64Value(const MCExpr *Value) { } // Associate TPRel32 fixup with data and resize data area -void MCObjectStreamer::EmitTPRel32Value(const MCExpr *Value) { +void MCObjectStreamer::emitTPRel32Value(const MCExpr *Value) { MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); @@ -631,7 +631,7 @@ void MCObjectStreamer::EmitTPRel32Value(const MCExpr *Value) { } // Associate TPRel64 fixup with data and resize data area -void MCObjectStreamer::EmitTPRel64Value(const MCExpr *Value) { +void MCObjectStreamer::emitTPRel64Value(const MCExpr *Value) { MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); @@ -641,7 +641,7 @@ void MCObjectStreamer::EmitTPRel64Value(const MCExpr *Value) { } // Associate GPRel32 fixup with data and resize data area -void MCObjectStreamer::EmitGPRel32Value(const MCExpr *Value) { +void MCObjectStreamer::emitGPRel32Value(const MCExpr *Value) { MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); @@ -651,7 +651,7 @@ void MCObjectStreamer::EmitGPRel32Value(const MCExpr *Value) { } // Associate GPRel64 fixup with data and resize data area -void MCObjectStreamer::EmitGPRel64Value(const MCExpr *Value) { +void MCObjectStreamer::emitGPRel64Value(const MCExpr *Value) { MCDataFragment *DF = getOrCreateDataFragment(); flushPendingLabels(DF, DF->getContents().size()); diff --git a/llvm/lib/MC/MCParser/AsmParser.cpp b/llvm/lib/MC/MCParser/AsmParser.cpp index b825aa9..b9aa95b 100644 --- a/llvm/lib/MC/MCParser/AsmParser.cpp +++ b/llvm/lib/MC/MCParser/AsmParser.cpp @@ -902,7 +902,7 @@ bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) { MCSection *Sec = getStreamer().getCurrentSectionOnly(); if (!Sec->getBeginSymbol()) { MCSymbol *SectionStartSym = getContext().createTempSymbol(); - getStreamer().EmitLabel(SectionStartSym); + getStreamer().emitLabel(SectionStartSym); Sec->setBeginSymbol(SectionStartSym); } bool InsertResult = getContext().addGenDwarfSection(Sec); @@ -1097,7 +1097,7 @@ bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) { // This is a '$' reference, which references the current PC. Emit a // temporary label to the streamer and refer to it. MCSymbol *Sym = Ctx.createTempSymbol(); - Out.EmitLabel(Sym); + Out.emitLabel(Sym); Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext()); EndLoc = FirstTokenLoc; @@ -1223,7 +1223,7 @@ bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) { // This is a '.' reference, which references the current PC. Emit a // temporary label to the streamer and refer to it. MCSymbol *Sym = Ctx.createTempSymbol(); - Out.EmitLabel(Sym); + Out.emitLabel(Sym); Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, getContext()); EndLoc = Lexer.getTok().getEndLoc(); Lex(); // Eat identifier. @@ -1854,7 +1854,7 @@ bool AsmParser::parseStatement(ParseStatementInfo &Info, // Emit the label. if (!getTargetParser().isParsingInlineAsm()) - Out.EmitLabel(Sym, IDLoc); + Out.emitLabel(Sym, IDLoc); // If we are generating dwarf for assembly source files then gather the // info to make a dwarf label entry for this label if needed. @@ -3335,10 +3335,10 @@ bool AsmParser::parseDirectiveAlign(bool IsPow2, unsigned ValueSize) { bool UseCodeAlign = Section->UseCodeAlign(); if ((!HasFillExpr || Lexer.getMAI().getTextAlignFillValue() == FillExpr) && ValueSize == 1 && UseCodeAlign) { - getStreamer().EmitCodeAlignment(Alignment, MaxBytesToFill); + getStreamer().emitCodeAlignment(Alignment, MaxBytesToFill); } else { // FIXME: Target specific behavior about how the "extra" bytes are filled. - getStreamer().EmitValueToAlignment(Alignment, FillExpr, ValueSize, + getStreamer().emitValueToAlignment(Alignment, FillExpr, ValueSize, MaxBytesToFill); } diff --git a/llvm/lib/MC/MCParser/DarwinAsmParser.cpp b/llvm/lib/MC/MCParser/DarwinAsmParser.cpp index bf6511c..9b925d8 100644 --- a/llvm/lib/MC/MCParser/DarwinAsmParser.cpp +++ b/llvm/lib/MC/MCParser/DarwinAsmParser.cpp @@ -492,7 +492,7 @@ bool DarwinAsmParser::parseSectionSwitch(StringRef Segment, StringRef Section, // is no good reason for someone to intentionally emit incorrectly sized // values into the implicitly aligned sections. if (Align) - getStreamer().EmitValueToAlignment(Align); + getStreamer().emitValueToAlignment(Align); return false; } diff --git a/llvm/lib/MC/MCParser/ELFAsmParser.cpp b/llvm/lib/MC/MCParser/ELFAsmParser.cpp index ceb8ea0..4e4272d 100644 --- a/llvm/lib/MC/MCParser/ELFAsmParser.cpp +++ b/llvm/lib/MC/MCParser/ELFAsmParser.cpp @@ -646,7 +646,7 @@ EndStmt: if (!ELFSection->getBeginSymbol()) { MCSymbol *SectionStartSymbol = getContext().createTempSymbol(); - getStreamer().EmitLabel(SectionStartSymbol); + getStreamer().emitLabel(SectionStartSymbol); ELFSection->setBeginSymbol(SectionStartSymbol); } } @@ -802,7 +802,7 @@ bool ELFAsmParser::ParseDirectiveVersion(StringRef, SMLoc) { getStreamer().EmitIntValue(1, 4); // type = NT_VERSION. getStreamer().emitBytes(Data); // name. getStreamer().EmitIntValue(0, 1); // terminate the string. - getStreamer().EmitValueToAlignment(4); // ensure 4 byte alignment. + getStreamer().emitValueToAlignment(4); // ensure 4 byte alignment. getStreamer().PopSection(); return false; } diff --git a/llvm/lib/MC/MCStreamer.cpp b/llvm/lib/MC/MCStreamer.cpp index fd16b10..83c5d14 100644 --- a/llvm/lib/MC/MCStreamer.cpp +++ b/llvm/lib/MC/MCStreamer.cpp @@ -160,41 +160,41 @@ void MCStreamer::emitSLEB128IntValue(int64_t Value) { } void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size, SMLoc Loc) { - EmitValueImpl(Value, Size, Loc); + emitValueImpl(Value, Size, Loc); } -void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size, +void MCStreamer::emitSymbolValue(const MCSymbol *Sym, unsigned Size, bool IsSectionRelative) { assert((!IsSectionRelative || Size == 4) && "SectionRelative value requires 4-bytes"); if (!IsSectionRelative) - EmitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size); + emitValueImpl(MCSymbolRefExpr::create(Sym, getContext()), Size); else EmitCOFFSecRel32(Sym, /*Offset=*/0); } -void MCStreamer::EmitDTPRel64Value(const MCExpr *Value) { +void MCStreamer::emitDTPRel64Value(const MCExpr *Value) { report_fatal_error("unsupported directive in streamer"); } -void MCStreamer::EmitDTPRel32Value(const MCExpr *Value) { +void MCStreamer::emitDTPRel32Value(const MCExpr *Value) { report_fatal_error("unsupported directive in streamer"); } -void MCStreamer::EmitTPRel64Value(const MCExpr *Value) { +void MCStreamer::emitTPRel64Value(const MCExpr *Value) { report_fatal_error("unsupported directive in streamer"); } -void MCStreamer::EmitTPRel32Value(const MCExpr *Value) { +void MCStreamer::emitTPRel32Value(const MCExpr *Value) { report_fatal_error("unsupported directive in streamer"); } -void MCStreamer::EmitGPRel64Value(const MCExpr *Value) { +void MCStreamer::emitGPRel64Value(const MCExpr *Value) { report_fatal_error("unsupported directive in streamer"); } -void MCStreamer::EmitGPRel32Value(const MCExpr *Value) { +void MCStreamer::emitGPRel32Value(const MCExpr *Value) { report_fatal_error("unsupported directive in streamer"); } @@ -396,7 +396,7 @@ void MCStreamer::AssignFragment(MCSymbol *Symbol, MCFragment *Fragment) { SymbolOrdering[Symbol] = 1 + SymbolOrdering.size(); } -void MCStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { +void MCStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { Symbol->redefineIfPossible(); if (!Symbol->isUndefined() || Symbol->isVariable()) @@ -1034,7 +1034,7 @@ void MCStreamer::emitAbsoluteSymbolDiff(const MCSymbol *Hi, const MCSymbol *Lo, // Otherwise, emit with .set (aka assignment). MCSymbol *SetLabel = Context.createTempSymbol("set", true); emitAssignment(SetLabel, Diff); - EmitSymbolValue(SetLabel, Size); + emitSymbolValue(SetLabel, Size); } void MCStreamer::emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi, @@ -1079,7 +1079,7 @@ void MCStreamer::ChangeSection(MCSection *, const MCExpr *) {} void MCStreamer::emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {} void MCStreamer::emitBytes(StringRef Data) {} void MCStreamer::emitBinaryData(StringRef Data) { emitBytes(Data); } -void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { +void MCStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { visitUsedExpr(*Value); } void MCStreamer::emitULEB128Value(const MCExpr *Value) {} @@ -1087,10 +1087,10 @@ void MCStreamer::emitSLEB128Value(const MCExpr *Value) {} void MCStreamer::emitFill(const MCExpr &NumBytes, uint64_t Value, SMLoc Loc) {} void MCStreamer::emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr, SMLoc Loc) {} -void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, +void MCStreamer::emitValueToAlignment(unsigned ByteAlignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit) {} -void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment, +void MCStreamer::emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit) {} void MCStreamer::emitValueToOffset(const MCExpr *Offset, unsigned char Value, SMLoc Loc) {} @@ -1109,7 +1109,7 @@ void MCStreamer::SwitchSection(MCSection *Section, const MCExpr *Subsection) { assert(!Section->hasEnded() && "Section already ended"); MCSymbol *Sym = Section->getBeginSymbol(); if (Sym && !Sym->isInSection()) - EmitLabel(Sym); + emitLabel(Sym); } } @@ -1121,7 +1121,7 @@ MCSymbol *MCStreamer::endSection(MCSection *Section) { return Sym; SwitchSection(Section); - EmitLabel(Sym); + emitLabel(Sym); return Sym; } diff --git a/llvm/lib/MC/MCWasmStreamer.cpp b/llvm/lib/MC/MCWasmStreamer.cpp index 05f3616..a5d92e5 100644 --- a/llvm/lib/MC/MCWasmStreamer.cpp +++ b/llvm/lib/MC/MCWasmStreamer.cpp @@ -148,15 +148,15 @@ void MCWasmStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size, llvm_unreachable("Local common symbols are not yet implemented for Wasm"); } -void MCWasmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, +void MCWasmStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { - MCObjectStreamer::EmitValueImpl(Value, Size, Loc); + MCObjectStreamer::emitValueImpl(Value, Size, Loc); } -void MCWasmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, +void MCWasmStreamer::emitValueToAlignment(unsigned ByteAlignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit) { - MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value, ValueSize, + MCObjectStreamer::emitValueToAlignment(ByteAlignment, Value, ValueSize, MaxBytesToEmit); } diff --git a/llvm/lib/MC/MCWin64EH.cpp b/llvm/lib/MC/MCWin64EH.cpp index 4e9a296..ca40b86 100644 --- a/llvm/lib/MC/MCWin64EH.cpp +++ b/llvm/lib/MC/MCWin64EH.cpp @@ -143,7 +143,7 @@ static void EmitRuntimeFunction(MCStreamer &streamer, const WinEH::FrameInfo *info) { MCContext &context = streamer.getContext(); - streamer.EmitValueToAlignment(4); + streamer.emitValueToAlignment(4); EmitSymbolRefWithOfs(streamer, info->Function, info->Begin); EmitSymbolRefWithOfs(streamer, info->Function, info->End); streamer.EmitValue(MCSymbolRefExpr::create(info->Symbol, @@ -159,8 +159,8 @@ static void EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info) { MCContext &context = streamer.getContext(); MCSymbol *Label = context.createTempSymbol(); - streamer.EmitValueToAlignment(4); - streamer.EmitLabel(Label); + streamer.emitValueToAlignment(4); + streamer.emitLabel(Label); info->Symbol = Label; // Upper 3 bits are the version number (currently 1). @@ -498,8 +498,8 @@ static void ARM64EmitUnwindInfo(MCStreamer &streamer, WinEH::FrameInfo *info) { MCContext &context = streamer.getContext(); MCSymbol *Label = context.createTempSymbol(); - streamer.EmitValueToAlignment(4); - streamer.EmitLabel(Label); + streamer.emitValueToAlignment(4); + streamer.emitLabel(Label); info->Symbol = Label; int64_t RawFuncLength; @@ -646,7 +646,7 @@ static void ARM64EmitRuntimeFunction(MCStreamer &streamer, const WinEH::FrameInfo *info) { MCContext &context = streamer.getContext(); - streamer.EmitValueToAlignment(4); + streamer.emitValueToAlignment(4); EmitSymbolRefWithOfs(streamer, info->Function, info->Begin); streamer.EmitValue(MCSymbolRefExpr::create(info->Symbol, MCSymbolRefExpr::VK_COFF_IMGREL32, diff --git a/llvm/lib/MC/MCWinCOFFStreamer.cpp b/llvm/lib/MC/MCWinCOFFStreamer.cpp index 66b3974..f492faa 100644 --- a/llvm/lib/MC/MCWinCOFFStreamer.cpp +++ b/llvm/lib/MC/MCWinCOFFStreamer.cpp @@ -71,20 +71,20 @@ void MCWinCOFFStreamer::InitSections(bool NoExecStack) { // This emulates the same behavior of GNU as. This makes it easier // to compare the output as the major sections are in the same order. SwitchSection(getContext().getObjectFileInfo()->getTextSection()); - EmitCodeAlignment(4); + emitCodeAlignment(4); SwitchSection(getContext().getObjectFileInfo()->getDataSection()); - EmitCodeAlignment(4); + emitCodeAlignment(4); SwitchSection(getContext().getObjectFileInfo()->getBSSSection()); - EmitCodeAlignment(4); + emitCodeAlignment(4); SwitchSection(getContext().getObjectFileInfo()->getTextSection()); } -void MCWinCOFFStreamer::EmitLabel(MCSymbol *S, SMLoc Loc) { +void MCWinCOFFStreamer::emitLabel(MCSymbol *S, SMLoc Loc) { auto *Symbol = cast(S); - MCObjectStreamer::EmitLabel(Symbol, Loc); + MCObjectStreamer::emitLabel(Symbol, Loc); } void MCWinCOFFStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) { @@ -301,8 +301,8 @@ void MCWinCOFFStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size, MCSection *Section = getContext().getObjectFileInfo()->getBSSSection(); PushSection(); SwitchSection(Section); - EmitValueToAlignment(ByteAlignment, 0, 1, 0); - EmitLabel(Symbol); + emitValueToAlignment(ByteAlignment, 0, 1, 0); + emitLabel(Symbol); Symbol->setExternal(false); EmitZeros(Size); PopSection(); diff --git a/llvm/lib/MC/MCXCOFFStreamer.cpp b/llvm/lib/MC/MCXCOFFStreamer.cpp index 95dd957..87a35f2 100644 --- a/llvm/lib/MC/MCXCOFFStreamer.cpp +++ b/llvm/lib/MC/MCXCOFFStreamer.cpp @@ -51,7 +51,7 @@ void MCXCOFFStreamer::emitCommonSymbol(MCSymbol *Symbol, uint64_t Size, Symbol->setCommon(Size, ByteAlignment); // Emit the alignment and storage for the variable to the section. - EmitValueToAlignment(ByteAlignment); + emitValueToAlignment(ByteAlignment); EmitZeros(Size); } diff --git a/llvm/lib/Object/RecordStreamer.cpp b/llvm/lib/Object/RecordStreamer.cpp index 6c70237..b2f973e 100644 --- a/llvm/lib/Object/RecordStreamer.cpp +++ b/llvm/lib/Object/RecordStreamer.cpp @@ -86,8 +86,8 @@ void RecordStreamer::emitInstruction(const MCInst &Inst, MCStreamer::emitInstruction(Inst, STI); } -void RecordStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { - MCStreamer::EmitLabel(Symbol); +void RecordStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { + MCStreamer::emitLabel(Symbol); markDefined(*Symbol); } diff --git a/llvm/lib/Object/RecordStreamer.h b/llvm/lib/Object/RecordStreamer.h index c1877a5..91d2723 100644 --- a/llvm/lib/Object/RecordStreamer.h +++ b/llvm/lib/Object/RecordStreamer.h @@ -47,7 +47,7 @@ public: RecordStreamer(MCContext &Context, const Module &M); void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override; - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override; bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override; void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size, diff --git a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp index a0e578c..d915264 100644 --- a/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp +++ b/llvm/lib/Target/AArch64/AArch64AsmPrinter.cpp @@ -290,9 +290,9 @@ void AArch64AsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) // ;DATA: higher 32 bits of the address of the trampoline // LDP X0, X30, [SP], #16 ; pop X0 and the link register from the stack // - OutStreamer->EmitCodeAlignment(4); + OutStreamer->emitCodeAlignment(4); auto CurSled = OutContext.createTempSymbol("xray_sled_", true); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitLabel(CurSled); auto Target = OutContext.createTempSymbol(); // Emit "B #32" instruction, which jumps over the next 28 bytes. @@ -303,7 +303,7 @@ void AArch64AsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) for (int8_t I = 0; I < NoopsInSledCount; I++) EmitToStreamer(*OutStreamer, MCInstBuilder(AArch64::HINT).addImm(0)); - OutStreamer->EmitLabel(Target); + OutStreamer->emitLabel(Target); recordSled(CurSled, MI, Kind); } @@ -366,7 +366,7 @@ void AArch64AsmPrinter::EmitHwasanMemaccessSymbols(Module &M) { OutStreamer->emitSymbolAttribute(Sym, MCSA_ELF_TypeFunction); OutStreamer->emitSymbolAttribute(Sym, MCSA_Weak); OutStreamer->emitSymbolAttribute(Sym, MCSA_Hidden); - OutStreamer->EmitLabel(Sym); + OutStreamer->emitLabel(Sym); OutStreamer->emitInstruction(MCInstBuilder(AArch64::UBFMXri) .addReg(AArch64::X16) @@ -396,10 +396,10 @@ void AArch64AsmPrinter::EmitHwasanMemaccessSymbols(Module &M) { OutContext)), *STI); MCSymbol *ReturnSym = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(ReturnSym); + OutStreamer->emitLabel(ReturnSym); OutStreamer->emitInstruction( MCInstBuilder(AArch64::RET).addReg(AArch64::LR), *STI); - OutStreamer->EmitLabel(HandleMismatchOrPartialSym); + OutStreamer->emitLabel(HandleMismatchOrPartialSym); if (IsShort) { OutStreamer->emitInstruction(MCInstBuilder(AArch64::SUBSWri) @@ -465,7 +465,7 @@ void AArch64AsmPrinter::EmitHwasanMemaccessSymbols(Module &M) { .addExpr(MCSymbolRefExpr::create(ReturnSym, OutContext)), *STI); - OutStreamer->EmitLabel(HandleMismatchSym); + OutStreamer->emitLabel(HandleMismatchSym); } OutStreamer->emitInstruction(MCInstBuilder(AArch64::STPXpre) @@ -783,7 +783,7 @@ void AArch64AsmPrinter::emitJumpTableInfo() { unsigned Size = AFI->getJumpTableEntrySize(JTI); emitAlignment(Align(Size)); - OutStreamer->EmitLabel(GetJTISymbol(JTI)); + OutStreamer->emitLabel(GetJTISymbol(JTI)); for (auto *JTBB : JTBBs) emitJumpTableEntry(MJTI, JTBB, JTI); @@ -867,7 +867,7 @@ void AArch64AsmPrinter::LowerSTACKMAP(MCStreamer &OutStreamer, StackMaps &SM, auto &Ctx = OutStreamer.getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer.EmitLabel(MILabel); + OutStreamer.emitLabel(MILabel); SM.recordStackMap(*MILabel, MI); assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!"); @@ -897,7 +897,7 @@ void AArch64AsmPrinter::LowerPATCHPOINT(MCStreamer &OutStreamer, StackMaps &SM, const MachineInstr &MI) { auto &Ctx = OutStreamer.getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer.EmitLabel(MILabel); + OutStreamer.emitLabel(MILabel); SM.recordPatchPoint(*MILabel, MI); PatchPointOpers Opers(&MI); @@ -991,7 +991,7 @@ void AArch64AsmPrinter::emitInstruction(const MachineInstr *MI) { MCSymbol *LOHLabel = createTempSymbol("loh"); // Associate the instruction with the label LOHInstToLabel[MI] = LOHLabel; - OutStreamer->EmitLabel(LOHLabel); + OutStreamer->emitLabel(LOHLabel); } AArch64TargetStreamer *TS = @@ -1014,7 +1014,7 @@ void AArch64AsmPrinter::emitInstruction(const MachineInstr *MI) { MCInstLowering.Lower(MI, Inst); EmitToStreamer(*OutStreamer, Inst); CurrentPatchableFunctionEntrySym = createTempSymbol("patch"); - OutStreamer->EmitLabel(CurrentPatchableFunctionEntrySym); + OutStreamer->emitLabel(CurrentPatchableFunctionEntrySym); return; } } diff --git a/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp b/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp index 5456209..cf049ec 100644 --- a/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp +++ b/llvm/lib/Target/AArch64/AArch64TargetObjectFile.cpp @@ -43,7 +43,7 @@ const MCExpr *AArch64_MachoTargetObjectFile::getTTypeGlobalReference( const MCExpr *Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOT, getContext()); MCSymbol *PCSym = getContext().createTempSymbol(); - Streamer.EmitLabel(PCSym); + Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext()); return MCBinaryExpr::createSub(Res, PC, getContext()); } @@ -68,7 +68,7 @@ const MCExpr *AArch64_MachoTargetObjectFile::getIndirectSymViaGOTPCRel( const MCExpr *Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOT, getContext()); MCSymbol *PCSym = getContext().createTempSymbol(); - Streamer.EmitLabel(PCSym); + Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext()); return MCBinaryExpr::createSub(Res, PC, getContext()); } diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp index a8abdc3..ab2131c 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFStreamer.cpp @@ -136,9 +136,9 @@ public: /// This is one of the functions used to emit data into an ELF section, so the /// AArch64 streamer overrides it to add the appropriate mapping symbol ($d) /// if necessary. - void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override { + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override { emitDataMappingSymbol(); - MCELFStreamer::EmitValueImpl(Value, Size, Loc); + MCELFStreamer::emitValueImpl(Value, Size, Loc); } void emitFill(const MCExpr &NumBytes, uint64_t FillValue, @@ -170,7 +170,7 @@ private: void EmitMappingSymbol(StringRef Name) { auto *Symbol = cast(getContext().getOrCreateSymbol( Name + "." + Twine(MappingSymbolCounter++))); - EmitLabel(Symbol); + emitLabel(Symbol); Symbol->setType(ELF::STT_NOTYPE); Symbol->setBinding(ELF::STB_LOCAL); Symbol->setExternal(false); diff --git a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp index 5926a4f..ad52c4d 100644 --- a/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp +++ b/llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCAsmInfo.cpp @@ -60,7 +60,7 @@ const MCExpr *AArch64MCAsmInfoDarwin::getExprForPersonalitySymbol( const MCExpr *Res = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_GOT, Context); MCSymbol *PCSym = Context.createTempSymbol(); - Streamer.EmitLabel(PCSym); + Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, Context); return MCBinaryExpr::createSub(Res, PC, Context); } diff --git a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp index 63702de..583c5da 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp @@ -218,7 +218,7 @@ void AMDGPUAsmPrinter::emitFunctionBodyEnd() { // CP microcode requires the kernel descriptor to be allocated on 64 byte // alignment. - Streamer.EmitValueToAlignment(64, 0, 1, 0); + Streamer.emitValueToAlignment(64, 0, 1, 0); if (ReadOnlySection.getAlignment() < 64) ReadOnlySection.setAlignment(Align(64)); diff --git a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp index a4eef5e..852f682 100644 --- a/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp +++ b/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.cpp @@ -445,9 +445,9 @@ void AMDGPUTargetELFStreamer::EmitNote( S.EmitValue(DescSZ, 4); // descz S.EmitIntValue(NoteType, 4); // type S.emitBytes(Name); // name - S.EmitValueToAlignment(4, 0, 1, 0); // padding 0 + S.emitValueToAlignment(4, 0, 1, 0); // padding 0 EmitDesc(S); // desc - S.EmitValueToAlignment(4, 0, 1, 0); // padding 0 + S.emitValueToAlignment(4, 0, 1, 0); // padding 0 S.PopSection(); } @@ -539,9 +539,9 @@ bool AMDGPUTargetELFStreamer::EmitISAVersion(StringRef IsaVersionString) { EmitNote(ElfNote::NoteNameV2, DescSZ, ELF::NT_AMD_AMDGPU_ISA, [&](MCELFStreamer &OS) { - OS.EmitLabel(DescBegin); + OS.emitLabel(DescBegin); OS.emitBytes(IsaVersionString); - OS.EmitLabel(DescEnd); + OS.emitLabel(DescEnd); }); return true; } @@ -566,9 +566,9 @@ bool AMDGPUTargetELFStreamer::EmitHSAMetadata(msgpack::Document &HSAMetadataDoc, EmitNote(ElfNote::NoteNameV3, DescSZ, ELF::NT_AMDGPU_METADATA, [&](MCELFStreamer &OS) { - OS.EmitLabel(DescBegin); + OS.emitLabel(DescBegin); OS.emitBytes(HSAMetadataString); - OS.EmitLabel(DescEnd); + OS.emitLabel(DescEnd); }); return true; } @@ -590,9 +590,9 @@ bool AMDGPUTargetELFStreamer::EmitHSAMetadata( EmitNote(ElfNote::NoteNameV2, DescSZ, ELF::NT_AMD_AMDGPU_HSA_METADATA, [&](MCELFStreamer &OS) { - OS.EmitLabel(DescBegin); + OS.emitLabel(DescBegin); OS.emitBytes(HSAMetadataString); - OS.EmitLabel(DescEnd); + OS.emitLabel(DescEnd); }); return true; } @@ -602,7 +602,7 @@ bool AMDGPUTargetELFStreamer::EmitCodeEnd() { MCStreamer &OS = getStreamer(); OS.PushSection(); - OS.EmitValueToAlignment(64, Encoded_s_code_end, 4); + OS.emitValueToAlignment(64, Encoded_s_code_end, 4); for (unsigned I = 0; I < 48; ++I) OS.EmitIntValue(Encoded_s_code_end, 4); OS.PopSection(); @@ -637,7 +637,7 @@ void AMDGPUTargetELFStreamer::EmitAmdhsaKernelDescriptor( if (KernelCodeSymbol->getVisibility() == ELF::STV_DEFAULT) KernelCodeSymbol->setVisibility(ELF::STV_PROTECTED); - Streamer.EmitLabel(KernelDescriptorSymbol); + Streamer.emitLabel(KernelDescriptorSymbol); Streamer.emitBytes(StringRef( (const char*)&(KernelDescriptor), offsetof(amdhsa::kernel_descriptor_t, kernel_code_entry_byte_offset))); diff --git a/llvm/lib/Target/ARM/ARMAsmPrinter.cpp b/llvm/lib/Target/ARM/ARMAsmPrinter.cpp index d2aeaea7..2aef3e3 100644 --- a/llvm/lib/Target/ARM/ARMAsmPrinter.cpp +++ b/llvm/lib/Target/ARM/ARMAsmPrinter.cpp @@ -73,7 +73,7 @@ void ARMAsmPrinter::emitFunctionEntryLabel() { } else { OutStreamer->emitAssemblerFlag(MCAF_Code32); } - OutStreamer->EmitLabel(CurrentFnSym); + OutStreamer->emitLabel(CurrentFnSym); } void ARMAsmPrinter::emitXXStructor(const DataLayout &DL, const Constant *CV) { @@ -170,7 +170,7 @@ bool ARMAsmPrinter::runOnMachineFunction(MachineFunction &MF) { OutStreamer->emitAssemblerFlag(MCAF_Code16); emitAlignment(Align(2)); for (std::pair &TIP : ThumbIndirectPads) { - OutStreamer->EmitLabel(TIP.second); + OutStreamer->emitLabel(TIP.second); EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tBX) .addReg(TIP.first) // Add predicate operands. @@ -491,7 +491,7 @@ static void emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel, MachineModuleInfoImpl::StubValueTy &MCSym) { // L_foo$stub: - OutStreamer.EmitLabel(StubLabel); + OutStreamer.emitLabel(StubLabel); // .indirect_symbol _foo OutStreamer.emitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol); @@ -877,7 +877,7 @@ void ARMAsmPrinter::emitMachineConstantPoolValue( for (const auto *GV : ACPC->promotedGlobals()) { if (!EmittedPromotedGlobalLabels.count(GV)) { MCSymbol *GVSym = getSymbol(GV); - OutStreamer->EmitLabel(GVSym); + OutStreamer->emitLabel(GVSym); EmittedPromotedGlobalLabels.insert(GV); } } @@ -926,7 +926,7 @@ void ARMAsmPrinter::emitMachineConstantPoolValue( // We want "( - .)", but MC doesn't have a concept of the '.' // label, so just emit a local label end reference that instead. MCSymbol *DotSym = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(DotSym); + OutStreamer->emitLabel(DotSym); const MCExpr *DotExpr = MCSymbolRefExpr::create(DotSym, OutContext); PCRelExpr = MCBinaryExpr::createSub(PCRelExpr, DotExpr, OutContext); } @@ -945,7 +945,7 @@ void ARMAsmPrinter::emitJumpTableAddrs(const MachineInstr *MI) { // Emit a label for the jump table. MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel(JTI); - OutStreamer->EmitLabel(JTISymbol); + OutStreamer->emitLabel(JTISymbol); // Mark the jump table as data-in-code. OutStreamer->emitDataRegion(MCDR_DataRegionJT32); @@ -991,7 +991,7 @@ void ARMAsmPrinter::emitJumpTableInsts(const MachineInstr *MI) { // Emit a label for the jump table. MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel(JTI); - OutStreamer->EmitLabel(JTISymbol); + OutStreamer->emitLabel(JTISymbol); // Emit each entry of the table. const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); @@ -1019,7 +1019,7 @@ void ARMAsmPrinter::emitJumpTableTBInst(const MachineInstr *MI, emitAlignment(Align(4)); MCSymbol *JTISymbol = GetARMJTIPICJumpTableLabel(JTI); - OutStreamer->EmitLabel(JTISymbol); + OutStreamer->emitLabel(JTISymbol); // Emit each entry of the table. const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo(); @@ -1514,7 +1514,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { // This is a pseudo op for a label used by a branch future instruction // Emit the label. - OutStreamer->EmitLabel(getBFLabel(DL.getPrivateGlobalPrefix(), + OutStreamer->emitLabel(getBFLabel(DL.getPrivateGlobalPrefix(), getFunctionNumber(), MI->getOperand(0).getIndex(), OutContext)); return; @@ -1526,7 +1526,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { // This adds the address of LPC0 to r0. // Emit the label. - OutStreamer->EmitLabel(getPICLabel(DL.getPrivateGlobalPrefix(), + OutStreamer->emitLabel(getPICLabel(DL.getPrivateGlobalPrefix(), getFunctionNumber(), MI->getOperand(2).getImm(), OutContext)); @@ -1547,7 +1547,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { // This adds the address of LPC0 to r0. // Emit the label. - OutStreamer->EmitLabel(getPICLabel(DL.getPrivateGlobalPrefix(), + OutStreamer->emitLabel(getPICLabel(DL.getPrivateGlobalPrefix(), getFunctionNumber(), MI->getOperand(2).getImm(), OutContext)); @@ -1578,7 +1578,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { // a PC-relative address at the ldr instruction. // Emit the label. - OutStreamer->EmitLabel(getPICLabel(DL.getPrivateGlobalPrefix(), + OutStreamer->emitLabel(getPICLabel(DL.getPrivateGlobalPrefix(), getFunctionNumber(), MI->getOperand(2).getImm(), OutContext)); @@ -1625,7 +1625,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { InConstantPool = true; } - OutStreamer->EmitLabel(GetCPISymbol(LabelId)); + OutStreamer->emitLabel(GetCPISymbol(LabelId)); const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx]; if (MCPE.isMachineConstantPoolEntry()) @@ -1657,7 +1657,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { case ARM::t2TBH_JT: { unsigned Opc = MI->getOpcode() == ARM::t2TBB_JT ? ARM::t2TBB : ARM::t2TBH; // Lower and emit the PC label, then the instruction itself. - OutStreamer->EmitLabel(GetCPISymbol(MI->getOperand(3).getImm())); + OutStreamer->emitLabel(GetCPISymbol(MI->getOperand(3).getImm())); EmitToStreamer(*OutStreamer, MCInstBuilder(Opc) .addReg(MI->getOperand(0).getReg()) .addReg(MI->getOperand(1).getReg()) @@ -1699,7 +1699,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { // FIXME: Ideally we could vary the LDRB index based on the padding // between the sequence and jump table, however that relies on MCExprs // for load indexes which are currently not supported. - OutStreamer->EmitCodeAlignment(4); + OutStreamer->emitCodeAlignment(4); EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDhirr) .addReg(Idx) .addReg(Idx) @@ -1741,7 +1741,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { .addImm(ARMCC::AL) .addReg(0)); - OutStreamer->EmitLabel(GetCPISymbol(MI->getOperand(3).getImm())); + OutStreamer->emitLabel(GetCPISymbol(MI->getOperand(3).getImm())); EmitToStreamer(*OutStreamer, MCInstBuilder(ARM::tADDhirr) .addReg(ARM::PC) .addReg(ARM::PC) @@ -1905,7 +1905,7 @@ void ARMAsmPrinter::emitInstruction(const MachineInstr *MI) { .addImm(ARMCC::AL) .addReg(0)); - OutStreamer->EmitLabel(Label); + OutStreamer->emitLabel(Label); return; } diff --git a/llvm/lib/Target/ARM/ARMMCInstLower.cpp b/llvm/lib/Target/ARM/ARMMCInstLower.cpp index 8e01b99..f8f6522 100644 --- a/llvm/lib/Target/ARM/ARMMCInstLower.cpp +++ b/llvm/lib/Target/ARM/ARMMCInstLower.cpp @@ -194,9 +194,9 @@ void ARMAsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) // BLX ip // POP{ r0, lr } // - OutStreamer->EmitCodeAlignment(4); + OutStreamer->emitCodeAlignment(4); auto CurSled = OutContext.createTempSymbol("xray_sled_", true); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitLabel(CurSled); auto Target = OutContext.createTempSymbol(); // Emit "B #20" instruction, which jumps over the next 24 bytes (because @@ -209,7 +209,7 @@ void ARMAsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) emitNops(NoopsInSledCount); - OutStreamer->EmitLabel(Target); + OutStreamer->emitLabel(Target); recordSled(CurSled, MI, Kind); } diff --git a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp index 38b2233..455d962 100644 --- a/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp +++ b/llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp @@ -8323,7 +8323,7 @@ bool ARMAsmParser::processInstruction(MCInst &Inst, // Reading PC provides the start of the current instruction + 8 and // the transform to adr is biased by that. MCSymbol *Dot = getContext().createTempSymbol(); - Out.EmitLabel(Dot); + Out.emitLabel(Dot); const MCExpr *OpExpr = Inst.getOperand(2).getExpr(); const MCExpr *InstPC = MCSymbolRefExpr::create(Dot, MCSymbolRefExpr::VK_None, @@ -11314,9 +11314,9 @@ bool ARMAsmParser::parseDirectiveEven(SMLoc L) { assert(Section && "must have section to emit alignment"); if (Section->UseCodeAlign()) - getStreamer().EmitCodeAlignment(2); + getStreamer().emitCodeAlignment(2); else - getStreamer().EmitValueToAlignment(2); + getStreamer().emitValueToAlignment(2); return false; } @@ -11516,9 +11516,9 @@ bool ARMAsmParser::parseDirectiveAlign(SMLoc L) { const MCSection *Section = getStreamer().getCurrentSectionOnly(); assert(Section && "must have section to emit alignment"); if (Section->UseCodeAlign()) - getStreamer().EmitCodeAlignment(4, 0); + getStreamer().emitCodeAlignment(4, 0); else - getStreamer().EmitValueToAlignment(4, 0, 1, 0); + getStreamer().emitValueToAlignment(4, 0, 1, 0); return false; } return true; diff --git a/llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp b/llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp index 4cf774f..88d12c5 100644 --- a/llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp +++ b/llvm/lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp @@ -543,7 +543,7 @@ public: /// This is one of the functions used to emit data into an ELF section, so the /// ARM streamer overrides it to add the appropriate mapping symbol ($d) if /// necessary. - void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override { + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override { if (const MCSymbolRefExpr *SRE = dyn_cast_or_null(Value)) { if (SRE->getKind() == MCSymbolRefExpr::VK_ARM_SBREL && !(Size == 4)) { getContext().reportError(Loc, "relocated expression must be 32-bit"); @@ -553,7 +553,7 @@ public: } emitDataMappingSymbol(); - MCELFStreamer::EmitValueImpl(Value, Size, Loc); + MCELFStreamer::emitValueImpl(Value, Size, Loc); } void emitAssemblerFlag(MCAssemblerFlag Flag) override { @@ -636,7 +636,7 @@ private: void EmitMappingSymbol(StringRef Name) { auto *Symbol = cast(getContext().getOrCreateSymbol( Name + "." + Twine(MappingSymbolCounter++))); - EmitLabel(Symbol); + emitLabel(Symbol); Symbol->setType(ELF::STT_NOTYPE); Symbol->setBinding(ELF::STB_LOCAL); @@ -1207,7 +1207,7 @@ inline void ARMELFStreamer::SwitchToEHSection(StringRef Prefix, // Switch to .ARM.extab or .ARM.exidx section SwitchSection(EHSection); - EmitCodeAlignment(4); + emitCodeAlignment(4); } inline void ARMELFStreamer::SwitchToExTabSection(const MCSymbol &FnStart) { @@ -1246,7 +1246,7 @@ void ARMELFStreamer::EHReset() { void ARMELFStreamer::emitFnStart() { assert(FnStart == nullptr); FnStart = getContext().createTempSymbol(); - EmitLabel(FnStart); + emitLabel(FnStart); } void ARMELFStreamer::emitFnEnd() { @@ -1354,7 +1354,7 @@ void ARMELFStreamer::FlushUnwindOpcodes(bool NoHandlerData) { // Create .ARM.extab label for offset in .ARM.exidx assert(!ExTab); ExTab = getContext().createTempSymbol(); - EmitLabel(ExTab); + emitLabel(ExTab); // Emit personality if (Personality) { diff --git a/llvm/lib/Target/BPF/BTFDebug.cpp b/llvm/lib/Target/BPF/BTFDebug.cpp index a81deac..3b50ed9 100644 --- a/llvm/lib/Target/BPF/BTFDebug.cpp +++ b/llvm/lib/Target/BPF/BTFDebug.cpp @@ -967,7 +967,7 @@ void BTFDebug::processReloc(const MachineOperand &MO) { auto *GVar = dyn_cast(GVal); if (GVar && GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr)) { MCSymbol *ORSym = OS.getContext().createTempSymbol(); - OS.EmitLabel(ORSym); + OS.emitLabel(ORSym); MDNode *MDN = GVar->getMetadata(LLVMContext::MD_preserve_access_index); DIType *Ty = dyn_cast(MDN); @@ -1040,7 +1040,7 @@ void BTFDebug::beginInstruction(const MachineInstr *MI) { // Create a temporary label to remember the insn for lineinfo. MCSymbol *LineSym = OS.getContext().createTempSymbol(); - OS.EmitLabel(LineSym); + OS.emitLabel(LineSym); // Construct the lineinfo. auto SP = DL.get()->getScope()->getSubprogram(); diff --git a/llvm/lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp b/llvm/lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp index 11cf9a7..109837a 100644 --- a/llvm/lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp +++ b/llvm/lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp @@ -1497,7 +1497,7 @@ int HexagonAsmParser::processInstruction(MCInst &Inst, MES->SwitchSection(mySection); unsigned byteSize = is32bit ? 4 : 8; - getStreamer().EmitCodeAlignment(byteSize, byteSize); + getStreamer().emitCodeAlignment(byteSize, byteSize); MCSymbol *Sym; @@ -1507,7 +1507,7 @@ int HexagonAsmParser::processInstruction(MCInst &Inst, if (Absolute) { Sym = getContext().getOrCreateSymbol(StringRef(myCharStr.c_str() + 16)); if (Sym->isUndefined()) { - getStreamer().EmitLabel(Sym); + getStreamer().emitLabel(Sym); getStreamer().emitSymbolAttribute(Sym, MCSA_Global); getStreamer().EmitIntValue(Value, byteSize); } @@ -1529,7 +1529,7 @@ int HexagonAsmParser::processInstruction(MCInst &Inst, if (Sym->isUndefined()) { // case where symbol is not yet defined: emit symbol - getStreamer().EmitLabel(Sym); + getStreamer().emitLabel(Sym); getStreamer().emitSymbolAttribute(Sym, MCSA_Local); getStreamer().EmitValue(MO_1.getExpr(), 4); } diff --git a/llvm/lib/Target/Hexagon/HexagonAsmPrinter.cpp b/llvm/lib/Target/Hexagon/HexagonAsmPrinter.cpp index 4628892..eb037ad 100644 --- a/llvm/lib/Target/Hexagon/HexagonAsmPrinter.cpp +++ b/llvm/lib/Target/Hexagon/HexagonAsmPrinter.cpp @@ -206,10 +206,10 @@ static MCSymbol *smallData(AsmPrinter &AP, const MachineInstr &MI, Sym = AP.OutContext.getOrCreateSymbol(Twine(symbolName)); if (Sym->isUndefined()) { - OutStreamer.EmitLabel(Sym); + OutStreamer.emitLabel(Sym); OutStreamer.emitSymbolAttribute(Sym, MCSA_Global); OutStreamer.EmitIntValue(Value, AlignSize); - OutStreamer.EmitCodeAlignment(AlignSize); + OutStreamer.emitCodeAlignment(AlignSize); } } else { assert(Imm.isExpr() && "Expected expression and found none"); @@ -234,10 +234,10 @@ static MCSymbol *smallData(AsmPrinter &AP, const MachineInstr &MI, OutStreamer.SwitchSection(Section); Sym = AP.OutContext.getOrCreateSymbol(Twine(LitaName)); if (Sym->isUndefined()) { - OutStreamer.EmitLabel(Sym); + OutStreamer.emitLabel(Sym); OutStreamer.emitSymbolAttribute(Sym, MCSA_Local); OutStreamer.EmitValue(Imm.getExpr(), AlignSize); - OutStreamer.EmitCodeAlignment(AlignSize); + OutStreamer.emitCodeAlignment(AlignSize); } } return Sym; diff --git a/llvm/lib/Target/Hexagon/HexagonTargetStreamer.h b/llvm/lib/Target/Hexagon/HexagonTargetStreamer.h index 78e78e3..a5b14a7 100644 --- a/llvm/lib/Target/Hexagon/HexagonTargetStreamer.h +++ b/llvm/lib/Target/Hexagon/HexagonTargetStreamer.h @@ -15,7 +15,7 @@ namespace llvm { class HexagonTargetStreamer : public MCTargetStreamer { public: HexagonTargetStreamer(MCStreamer &S) : MCTargetStreamer(S) {} - virtual void EmitCodeAlignment(unsigned ByteAlignment, + virtual void emitCodeAlignment(unsigned ByteAlignment, unsigned MaxBytesToEmit = 0){}; virtual void emitFAlign(unsigned Size, unsigned MaxBytesToEmit){}; virtual void emitCommonSymbolSorted(MCSymbol *Symbol, uint64_t Size, diff --git a/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp b/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp index b580b4a..b8dd8ed 100644 --- a/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp +++ b/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp @@ -110,8 +110,8 @@ void HexagonMCELFStreamer::HexagonMCEmitCommonSymbol(MCSymbol *Symbol, SwitchSection(&Section); if (ELFSymbol->isUndefined()) { - EmitValueToAlignment(ByteAlignment, 0, 1, 0); - EmitLabel(Symbol); + emitValueToAlignment(ByteAlignment, 0, 1, 0); + emitLabel(Symbol); EmitZeros(Size); } diff --git a/llvm/lib/Target/MSP430/MSP430AsmPrinter.cpp b/llvm/lib/Target/MSP430/MSP430AsmPrinter.cpp index 4576ca3..4591884 100644 --- a/llvm/lib/Target/MSP430/MSP430AsmPrinter.cpp +++ b/llvm/lib/Target/MSP430/MSP430AsmPrinter.cpp @@ -169,7 +169,7 @@ void MSP430AsmPrinter::EmitInterruptVectorSection(MachineFunction &ISR) { OutStreamer->SwitchSection(IV); const MCSymbol *FunctionSymbol = getSymbol(F); - OutStreamer->EmitSymbolValue(FunctionSymbol, TM.getProgramPointerSize()); + OutStreamer->emitSymbolValue(FunctionSymbol, TM.getProgramPointerSize()); OutStreamer->SwitchSection(Cur); } diff --git a/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp b/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp index 4101da9..1ceb079 100644 --- a/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp +++ b/llvm/lib/Target/Mips/AsmParser/MipsAsmParser.cpp @@ -2131,7 +2131,7 @@ bool MipsAsmParser::processInstruction(MCInst &Inst, SMLoc IDLoc, TOut.getStreamer().EmitRelocDirective(*TmpExpr, inMicroMipsMode() ? "R_MICROMIPS_JALR" : "R_MIPS_JALR", RelocJalrExpr, IDLoc, *STI); - TOut.getStreamer().EmitLabel(TmpLabel); + TOut.getStreamer().emitLabel(TmpLabel); } Inst = JalrInst; @@ -3388,7 +3388,7 @@ bool MipsAsmParser::expandLoadSingleImmToFPR(MCInst &Inst, SMLoc IDLoc, MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext()); getStreamer().SwitchSection(ReadOnlySection); - getStreamer().EmitLabel(Sym, IDLoc); + getStreamer().emitLabel(Sym, IDLoc); getStreamer().EmitIntValue(ImmOp32, 4); getStreamer().SwitchSection(CS); @@ -3440,8 +3440,8 @@ bool MipsAsmParser::expandLoadDoubleImmToGPR(MCInst &Inst, SMLoc IDLoc, MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext()); getStreamer().SwitchSection(ReadOnlySection); - getStreamer().EmitLabel(Sym, IDLoc); - getStreamer().EmitValueToAlignment(8); + getStreamer().emitLabel(Sym, IDLoc); + getStreamer().emitValueToAlignment(8); getStreamer().EmitIntValue(ImmOp64, 8); getStreamer().SwitchSection(CS); @@ -3523,8 +3523,8 @@ bool MipsAsmParser::expandLoadDoubleImmToFPR(MCInst &Inst, bool Is64FPU, MipsMCExpr::create(MipsMCExpr::MEK_LO, LoSym, getContext()); getStreamer().SwitchSection(ReadOnlySection); - getStreamer().EmitLabel(Sym, IDLoc); - getStreamer().EmitValueToAlignment(8); + getStreamer().emitLabel(Sym, IDLoc); + getStreamer().emitValueToAlignment(8); getStreamer().EmitIntValue(ImmOp64, 8); getStreamer().SwitchSection(CS); @@ -4260,7 +4260,7 @@ bool MipsAsmParser::expandDivRem(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out, if (!Signed) { if (!UseTraps) - TOut.getStreamer().EmitLabel(BrTarget); + TOut.getStreamer().emitLabel(BrTarget); TOut.emitR(isDiv ? Mips::MFLO : Mips::MFHI, RdReg, IDLoc, STI); return false; @@ -4271,7 +4271,7 @@ bool MipsAsmParser::expandDivRem(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out, return true; if (!UseTraps) - TOut.getStreamer().EmitLabel(BrTarget); + TOut.getStreamer().emitLabel(BrTarget); TOut.emitRRI(Mips::ADDiu, ATReg, ZeroReg, -1, IDLoc, STI); @@ -4299,7 +4299,7 @@ bool MipsAsmParser::expandDivRem(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out, TOut.emitII(Mips::BREAK, 0x6, 0, IDLoc, STI); } - TOut.getStreamer().EmitLabel(BrTargetEnd); + TOut.getStreamer().emitLabel(BrTargetEnd); TOut.emitR(isDiv ? Mips::MFLO : Mips::MFHI, RdReg, IDLoc, STI); return false; } @@ -5101,7 +5101,7 @@ bool MipsAsmParser::expandMulO(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out, TOut.emitNop(IDLoc, STI); TOut.emitII(Mips::BREAK, 6, 0, IDLoc, STI); - TOut.getStreamer().EmitLabel(BrTarget); + TOut.getStreamer().emitLabel(BrTarget); } TOut.emitR(Mips::MFLO, DstReg, IDLoc, STI); @@ -5138,7 +5138,7 @@ bool MipsAsmParser::expandMulOU(MCInst &Inst, SMLoc IDLoc, MCStreamer &Out, TOut.emitNop(IDLoc, STI); TOut.emitII(Mips::BREAK, 6, 0, IDLoc, STI); - TOut.getStreamer().EmitLabel(BrTarget); + TOut.getStreamer().emitLabel(BrTarget); } return false; @@ -7770,7 +7770,7 @@ bool MipsAsmParser::parseDirectiveGpWord() { // method to evaluate the expression. if (getParser().parseExpression(Value)) return true; - getParser().getStreamer().EmitGPRel32Value(Value); + getParser().getStreamer().emitGPRel32Value(Value); if (getLexer().isNot(AsmToken::EndOfStatement)) return Error(getLexer().getLoc(), @@ -7788,7 +7788,7 @@ bool MipsAsmParser::parseDirectiveGpDWord() { // method to evaluate the expression. if (getParser().parseExpression(Value)) return true; - getParser().getStreamer().EmitGPRel64Value(Value); + getParser().getStreamer().emitGPRel64Value(Value); if (getLexer().isNot(AsmToken::EndOfStatement)) return Error(getLexer().getLoc(), @@ -7806,7 +7806,7 @@ bool MipsAsmParser::parseDirectiveDtpRelWord() { // method to evaluate the expression. if (getParser().parseExpression(Value)) return true; - getParser().getStreamer().EmitDTPRel32Value(Value); + getParser().getStreamer().emitDTPRel32Value(Value); if (getLexer().isNot(AsmToken::EndOfStatement)) return Error(getLexer().getLoc(), @@ -7824,7 +7824,7 @@ bool MipsAsmParser::parseDirectiveDtpRelDWord() { // method to evaluate the expression. if (getParser().parseExpression(Value)) return true; - getParser().getStreamer().EmitDTPRel64Value(Value); + getParser().getStreamer().emitDTPRel64Value(Value); if (getLexer().isNot(AsmToken::EndOfStatement)) return Error(getLexer().getLoc(), @@ -7842,7 +7842,7 @@ bool MipsAsmParser::parseDirectiveTpRelWord() { // method to evaluate the expression. if (getParser().parseExpression(Value)) return true; - getParser().getStreamer().EmitTPRel32Value(Value); + getParser().getStreamer().emitTPRel32Value(Value); if (getLexer().isNot(AsmToken::EndOfStatement)) return Error(getLexer().getLoc(), @@ -7860,7 +7860,7 @@ bool MipsAsmParser::parseDirectiveTpRelDWord() { // method to evaluate the expression. if (getParser().parseExpression(Value)) return true; - getParser().getStreamer().EmitTPRel64Value(Value); + getParser().getStreamer().emitTPRel64Value(Value); if (getLexer().isNot(AsmToken::EndOfStatement)) return Error(getLexer().getLoc(), diff --git a/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp b/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp index cfe4353..1051fdc 100644 --- a/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp +++ b/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.cpp @@ -55,18 +55,18 @@ void MipsELFStreamer::emitInstruction(const MCInst &Inst, void MipsELFStreamer::emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) { Frame.Begin = getContext().createTempSymbol(); - MCELFStreamer::EmitLabel(Frame.Begin); + MCELFStreamer::emitLabel(Frame.Begin); } MCSymbol *MipsELFStreamer::emitCFILabel() { MCSymbol *Label = getContext().createTempSymbol("cfi", true); - MCELFStreamer::EmitLabel(Label); + MCELFStreamer::emitLabel(Label); return Label; } void MipsELFStreamer::emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) { Frame.End = getContext().createTempSymbol(); - MCELFStreamer::EmitLabel(Frame.End); + MCELFStreamer::emitLabel(Frame.End); } void MipsELFStreamer::createPendingLabelRelocs() { @@ -85,8 +85,8 @@ void MipsELFStreamer::createPendingLabelRelocs() { Labels.clear(); } -void MipsELFStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { - MCELFStreamer::EmitLabel(Symbol); +void MipsELFStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { + MCELFStreamer::emitLabel(Symbol); Labels.push_back(Symbol); } @@ -96,9 +96,9 @@ void MipsELFStreamer::SwitchSection(MCSection *Section, Labels.clear(); } -void MipsELFStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, +void MipsELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) { - MCELFStreamer::EmitValueImpl(Value, Size, Loc); + MCELFStreamer::emitValueImpl(Value, Size, Loc); Labels.clear(); } diff --git a/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h b/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h index 451b1b0..129bcd2 100644 --- a/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h +++ b/llvm/lib/Target/Mips/MCTargetDesc/MipsELFStreamer.h @@ -46,7 +46,7 @@ public: /// Overriding this function allows us to record all labels that should be /// marked as microMIPS. Based on this data marking is done in /// EmitInstruction. - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; /// Overriding this function allows us to dismiss all labels that are /// candidates for marking as microMIPS when .section directive is processed. @@ -56,7 +56,7 @@ public: /// Overriding these functions allows us to dismiss all labels that are /// candidates for marking as microMIPS when .word/.long/.4byte etc /// directives are emitted. - void EmitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override; + void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override; void EmitIntValue(uint64_t Value, unsigned Size) override; // Overriding these functions allows us to avoid recording of these labels diff --git a/llvm/lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp b/llvm/lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp index 88dcab6..0deeada 100644 --- a/llvm/lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp +++ b/llvm/lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp @@ -883,9 +883,9 @@ void MipsTargetELFStreamer::finish() { if (Alignment) { OS.SwitchSection(&Section); if (Section.UseCodeAlign()) - OS.EmitCodeAlignment(Alignment, Alignment); + OS.emitCodeAlignment(Alignment, Alignment); else - OS.EmitValueToAlignment(Alignment, 0, 1, Alignment); + OS.emitValueToAlignment(Alignment, 0, 1, Alignment); } } } @@ -997,7 +997,7 @@ void MipsTargetELFStreamer::emitDirectiveEnd(StringRef Name) { OS.SwitchSection(Sec); - OS.EmitValueImpl(ExprRef, 4); + OS.emitValueImpl(ExprRef, 4); OS.EmitIntValue(GPRInfoSet ? GPRBitMask : 0, 4); // reg_mask OS.EmitIntValue(GPRInfoSet ? GPROffset : 0, 4); // reg_offset @@ -1017,7 +1017,7 @@ void MipsTargetELFStreamer::emitDirectiveEnd(StringRef Name) { // .end also implicitly sets the size. MCSymbol *CurPCSym = Context.createTempSymbol(); - OS.EmitLabel(CurPCSym); + OS.emitLabel(CurPCSym); const MCExpr *Size = MCBinaryExpr::createSub( MCSymbolRefExpr::create(CurPCSym, MCSymbolRefExpr::VK_None, Context), ExprRef, Context); diff --git a/llvm/lib/Target/Mips/MipsAsmPrinter.cpp b/llvm/lib/Target/Mips/MipsAsmPrinter.cpp index a16c038..bfd730b 100644 --- a/llvm/lib/Target/Mips/MipsAsmPrinter.cpp +++ b/llvm/lib/Target/Mips/MipsAsmPrinter.cpp @@ -178,7 +178,7 @@ static void emitDirectiveRelocJalr(const MachineInstr &MI, (*OffsetExpr, Subtarget.inMicroMipsMode() ? "R_MICROMIPS_JALR" : "R_MIPS_JALR", CaleeExpr, SMLoc(), *TM.getMCSubtargetInfo()); - OutStreamer.EmitLabel(OffsetLabel); + OutStreamer.emitLabel(OffsetLabel); return; } } @@ -222,7 +222,7 @@ void MipsAsmPrinter::emitInstruction(const MachineInstr *MI) { InConstantPool = true; } - OutStreamer->EmitLabel(GetCPISymbol(LabelId)); + OutStreamer->emitLabel(GetCPISymbol(LabelId)); const MachineConstantPoolEntry &MCPE = MCP->getConstants()[CPIdx]; if (MCPE.isMachineConstantPoolEntry()) @@ -419,7 +419,7 @@ void MipsAsmPrinter::emitFunctionEntryLabel() { TS.emitDirectiveSetNoMips16(); TS.emitDirectiveEnt(*CurrentFnSym); - OutStreamer->EmitLabel(CurrentFnSym); + OutStreamer->emitLabel(CurrentFnSym); } /// EmitFunctionBodyStart - Targets can override this to emit stuff before @@ -1054,7 +1054,7 @@ void MipsAsmPrinter::EmitFPCallStub( // // .align 2 // - OutStreamer->EmitValueToAlignment(4); + OutStreamer->emitValueToAlignment(4); MipsTargetStreamer &TS = getTargetStreamer(); // // .set nomips16 @@ -1074,7 +1074,7 @@ void MipsAsmPrinter::EmitFPCallStub( MCSymbol *MType = OutContext.getOrCreateSymbol("__call_stub_fp_" + Twine(Symbol)); OutStreamer->emitSymbolAttribute(MType, MCSA_ELF_TypeFunction); - OutStreamer->EmitLabel(Stub); + OutStreamer->emitLabel(Stub); // Only handle non-pic for now. assert(!isPositionIndependent() && @@ -1113,7 +1113,7 @@ void MipsAsmPrinter::EmitFPCallStub( EmitInstrReg(*STI, Mips::JR, Mips::S2); MCSymbol *Tmp = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(Tmp); + OutStreamer->emitLabel(Tmp); const MCSymbolRefExpr *E = MCSymbolRefExpr::create(Stub, OutContext); const MCSymbolRefExpr *T = MCSymbolRefExpr::create(Tmp, OutContext); const MCExpr *T_min_E = MCBinaryExpr::createSub(T, E, OutContext); @@ -1203,9 +1203,9 @@ void MipsAsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) { // LD RA, 8(SP) // DADDIU SP, SP, 16 // - OutStreamer->EmitCodeAlignment(4); + OutStreamer->emitCodeAlignment(4); auto CurSled = OutContext.createTempSymbol("xray_sled_", true); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitLabel(CurSled); auto Target = OutContext.createTempSymbol(); // Emit "B .tmpN" instruction, which jumps over the nop sled to the actual @@ -1223,7 +1223,7 @@ void MipsAsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) { .addReg(Mips::ZERO) .addImm(0)); - OutStreamer->EmitLabel(Target); + OutStreamer->emitLabel(Target); if (!Subtarget->isGP64bit()) { EmitToStreamer(*OutStreamer, @@ -1260,10 +1260,10 @@ void MipsAsmPrinter::emitDebugValue(const MCExpr *Value, unsigned Size) const { if (MipsExpr && MipsExpr->getKind() == MipsMCExpr::MEK_DTPREL) { switch (Size) { case 4: - OutStreamer->EmitDTPRel32Value(MipsExpr->getSubExpr()); + OutStreamer->emitDTPRel32Value(MipsExpr->getSubExpr()); break; case 8: - OutStreamer->EmitDTPRel64Value(MipsExpr->getSubExpr()); + OutStreamer->emitDTPRel64Value(MipsExpr->getSubExpr()); break; default: llvm_unreachable("Unexpected size of expression value."); diff --git a/llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp b/llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp index 6bda0b0..f7f0ccc 100644 --- a/llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp +++ b/llvm/lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp @@ -1702,7 +1702,7 @@ bool PPCAsmParser::ParseDirectiveTC(unsigned Size, AsmToken ID) { return addErrorSuffix(" in '.tc' directive"); // Align to word size. - getParser().getStreamer().EmitValueToAlignment(Size); + getParser().getStreamer().emitValueToAlignment(Size); // Emit expressions. return ParseDirectiveWord(Size, ID); diff --git a/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp b/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp index 1851665..c9760ed 100644 --- a/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp +++ b/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp @@ -65,7 +65,7 @@ void PPCELFStreamer::emitInstruction(const MCInst &Inst, // all of the nops required as part of the alignment operation. In the cases // when no nops are added then The fragment is still created but it remains // empty. - EmitCodeAlignment(64, 4); + emitCodeAlignment(64, 4); // Emit the instruction. // Since the previous emit created a new fragment then adding this instruction @@ -93,10 +93,10 @@ void PPCELFStreamer::emitInstruction(const MCInst &Inst, } } -void PPCELFStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) { +void PPCELFStreamer::emitLabel(MCSymbol *Symbol, SMLoc Loc) { LastLabel = Symbol; LastLabelLoc = Loc; - MCELFStreamer::EmitLabel(Symbol); + MCELFStreamer::emitLabel(Symbol); } MCELFStreamer *llvm::createPPCELFStreamer( diff --git a/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.h b/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.h index 2585c01..403681e 100644 --- a/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.h +++ b/llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFStreamer.h @@ -40,7 +40,7 @@ public: void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override; // EmitLabel updates LastLabel and LastLabelLoc when a new label is emitted. - void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; + void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override; }; MCELFStreamer *createPPCELFStreamer(MCContext &Context, diff --git a/llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp b/llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp index a1717e3..9d3ecc0 100644 --- a/llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp +++ b/llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp @@ -159,8 +159,8 @@ public: void emitTCEntry(const MCSymbol &S) override { // Creates a R_PPC64_TOC relocation - Streamer.EmitValueToAlignment(8); - Streamer.EmitSymbolValue(&S, 8); + Streamer.emitValueToAlignment(8); + Streamer.emitSymbolValue(&S, 8); } void emitMachine(StringRef CPU) override { @@ -261,8 +261,8 @@ public: void emitTCEntry(const MCSymbol &S) override { const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo(); const unsigned PointerSize = MAI->getCodePointerSize(); - Streamer.EmitValueToAlignment(PointerSize); - Streamer.EmitSymbolValue(&S, PointerSize); + Streamer.emitValueToAlignment(PointerSize); + Streamer.emitSymbolValue(&S, PointerSize); } void emitMachine(StringRef CPU) override { diff --git a/llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp b/llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp index 4986a36..5e5a63d 100644 --- a/llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp +++ b/llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp @@ -326,7 +326,7 @@ void PPCAsmPrinter::LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI) { auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordStackMap(*MILabel, MI); assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!"); @@ -355,7 +355,7 @@ void PPCAsmPrinter::LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI) { void PPCAsmPrinter::LowerPATCHPOINT(StackMaps &SM, const MachineInstr &MI) { auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordPatchPoint(*MILabel, MI); PatchPointOpers Opers(&MI); @@ -591,7 +591,7 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) { .addExpr(MCSymbolRefExpr::create(PICBase, OutContext))); // Emit the label. - OutStreamer->EmitLabel(PICBase); + OutStreamer->emitLabel(PICBase); return; } case PPC::UpdateGBR: { @@ -935,9 +935,9 @@ void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) { MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol, OutContext), MCSymbolRefExpr::create(GOTRef, OutContext), OutContext); - OutStreamer->EmitLabel(GOTRef); + OutStreamer->emitLabel(GOTRef); OutStreamer->EmitValue(OffsExpr, 4); - OutStreamer->EmitLabel(NextInstr); + OutStreamer->emitLabel(NextInstr); EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR) .addReg(MI->getOperand(0).getReg())); EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LWZ) @@ -1170,7 +1170,7 @@ void PPCLinuxAsmPrinter::emitInstruction(const MachineInstr *MI) { // of instructions change. MCSymbol *BeginOfSled = OutContext.createTempSymbol(); MCSymbol *EndOfSled = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(BeginOfSled); + OutStreamer->emitLabel(BeginOfSled); EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::B).addExpr( MCSymbolRefExpr::create(EndOfSled, OutContext))); @@ -1185,7 +1185,7 @@ void PPCLinuxAsmPrinter::emitInstruction(const MachineInstr *MI) { OutContext.getOrCreateSymbol("__xray_FunctionEntry"), OutContext))); EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR8).addReg(PPC::X0)); - OutStreamer->EmitLabel(EndOfSled); + OutStreamer->emitLabel(EndOfSled); recordSled(BeginOfSled, *MI, SledKind::FUNCTION_ENTER); break; } @@ -1256,9 +1256,9 @@ void PPCLinuxAsmPrinter::emitInstruction(const MachineInstr *MI) { // // Update compiler-rt/lib/xray/xray_powerpc64.cc accordingly when number // of instructions change. - OutStreamer->EmitCodeAlignment(8); + OutStreamer->emitCodeAlignment(8); MCSymbol *BeginOfSled = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(BeginOfSled); + OutStreamer->emitLabel(BeginOfSled); EmitToStreamer(*OutStreamer, RetInst); EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP)); EmitToStreamer( @@ -1273,7 +1273,7 @@ void PPCLinuxAsmPrinter::emitInstruction(const MachineInstr *MI) { EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR8).addReg(PPC::X0)); EmitToStreamer(*OutStreamer, RetInst); if (IsConditional) - OutStreamer->EmitLabel(FallthroughLabel); + OutStreamer->emitLabel(FallthroughLabel); recordSled(BeginOfSled, *MI, SledKind::FUNCTION_EXIT); break; } @@ -1309,7 +1309,7 @@ void PPCLinuxAsmPrinter::emitStartOfAsmFile(Module &M) { MCSymbol *TOCSym = OutContext.getOrCreateSymbol(Twine(".LTOC")); MCSymbol *CurrentPos = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(CurrentPos); + OutStreamer->emitLabel(CurrentPos); // The GOT pointer points to the middle of the GOT, in order to reference the // entire 64kB range. 0x8000 is the midpoint. @@ -1335,7 +1335,7 @@ void PPCLinuxAsmPrinter::emitFunctionEntryLabel() { if (PPCFI->usesPICBase() && !Subtarget->isSecurePlt()) { MCSymbol *RelocSymbol = PPCFI->getPICOffsetSymbol(); MCSymbol *PICBase = MF->getPICBaseSymbol(); - OutStreamer->EmitLabel(RelocSymbol); + OutStreamer->emitLabel(RelocSymbol); const MCExpr *OffsExpr = MCBinaryExpr::createSub( @@ -1344,7 +1344,7 @@ void PPCLinuxAsmPrinter::emitFunctionEntryLabel() { MCSymbolRefExpr::create(PICBase, OutContext), OutContext); OutStreamer->EmitValue(OffsExpr, 4); - OutStreamer->EmitLabel(CurrentFnSym); + OutStreamer->emitLabel(CurrentFnSym); return; } else return AsmPrinter::emitFunctionEntryLabel(); @@ -1368,7 +1368,7 @@ void PPCLinuxAsmPrinter::emitFunctionEntryLabel() { OutContext), OutContext); - OutStreamer->EmitLabel(PPCFI->getTOCOffsetSymbol()); + OutStreamer->emitLabel(PPCFI->getTOCOffsetSymbol()); OutStreamer->EmitValue(TOCDeltaExpr, 8); } return AsmPrinter::emitFunctionEntryLabel(); @@ -1379,8 +1379,8 @@ void PPCLinuxAsmPrinter::emitFunctionEntryLabel() { MCSectionELF *Section = OutStreamer->getContext().getELFSection( ".opd", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC); OutStreamer->SwitchSection(Section); - OutStreamer->EmitLabel(CurrentFnSym); - OutStreamer->EmitValueToAlignment(8); + OutStreamer->emitLabel(CurrentFnSym); + OutStreamer->emitValueToAlignment(8); MCSymbol *Symbol1 = CurrentFnSymForSize; // Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function // entry point. @@ -1419,12 +1419,12 @@ bool PPCLinuxAsmPrinter::doFinalization(Module &M) { const MCSymbol *const TOCEntryTarget = TOCMapPair.first; MCSymbol *const TOCEntryLabel = TOCMapPair.second; - OutStreamer->EmitLabel(TOCEntryLabel); + OutStreamer->emitLabel(TOCEntryLabel); if (isPPC64) { TS.emitTCEntry(*TOCEntryTarget); } else { - OutStreamer->EmitValueToAlignment(4); - OutStreamer->EmitSymbolValue(TOCEntryTarget, 4); + OutStreamer->emitValueToAlignment(4); + OutStreamer->emitSymbolValue(TOCEntryTarget, 4); } } } @@ -1474,7 +1474,7 @@ void PPCLinuxAsmPrinter::emitFunctionBodyStart() { const PPCFunctionInfo *PPCFI = MF->getInfo(); MCSymbol *GlobalEntryLabel = PPCFI->getGlobalEPSymbol(); - OutStreamer->EmitLabel(GlobalEntryLabel); + OutStreamer->emitLabel(GlobalEntryLabel); const MCSymbolRefExpr *GlobalEntryLabelExp = MCSymbolRefExpr::create(GlobalEntryLabel, OutContext); @@ -1512,7 +1512,7 @@ void PPCLinuxAsmPrinter::emitFunctionBodyStart() { } MCSymbol *LocalEntryLabel = PPCFI->getLocalEPSymbol(); - OutStreamer->EmitLabel(LocalEntryLabel); + OutStreamer->emitLabel(LocalEntryLabel); const MCSymbolRefExpr *LocalEntryLabelExp = MCSymbolRefExpr::create(LocalEntryLabel, OutContext); const MCExpr *LocalOffsetExp = @@ -1633,7 +1633,7 @@ void PPCAIXAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { MCSymbol *EmittedInitSym = GVSym; emitLinkage(GV, EmittedInitSym); emitAlignment(getGVAlignment(GV, DL), GV); - OutStreamer->EmitLabel(EmittedInitSym); + OutStreamer->emitLabel(EmittedInitSym); emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer()); } @@ -1645,7 +1645,7 @@ void PPCAIXAsmPrinter::emitFunctionDescriptor() { // Emit function descriptor. OutStreamer->SwitchSection( cast(CurrentFnDescSym)->getContainingCsect()); - OutStreamer->EmitLabel(CurrentFnDescSym); + OutStreamer->emitLabel(CurrentFnDescSym); // Emit function entry point address. OutStreamer->EmitValue(MCSymbolRefExpr::create(CurrentFnSym, OutContext), PointerSize); @@ -1690,7 +1690,7 @@ void PPCAIXAsmPrinter::emitEndOfAsmFile(Module &M) { cast(I.second)->setContainingCsect(TCEntry); OutStreamer->SwitchSection(TCEntry); - OutStreamer->EmitLabel(I.second); + OutStreamer->emitLabel(I.second); TS.emitTCEntry(*I.first); } } diff --git a/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp b/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp index 952277f..62b6d9b 100644 --- a/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp +++ b/llvm/lib/Target/RISCV/AsmParser/RISCVAsmParser.cpp @@ -1718,7 +1718,7 @@ void RISCVAsmParser::emitAuipcInstPair(MCOperand DestReg, MCOperand TmpReg, MCSymbol *TmpLabel = Ctx.createTempSymbol( "pcrel_hi", /* AlwaysAddSuffix */ true, /* CanBeUnnamed */ false); - Out.EmitLabel(TmpLabel); + Out.emitLabel(TmpLabel); const RISCVMCExpr *SymbolHi = RISCVMCExpr::create(Symbol, VKHi, Ctx); emitToStreamer( diff --git a/llvm/lib/Target/Sparc/SparcAsmPrinter.cpp b/llvm/lib/Target/Sparc/SparcAsmPrinter.cpp index b4860c8..069e43c 100644 --- a/llvm/lib/Target/Sparc/SparcAsmPrinter.cpp +++ b/llvm/lib/Target/Sparc/SparcAsmPrinter.cpp @@ -233,15 +233,15 @@ void SparcAsmPrinter::LowerGETPCXAndEmitMCInsts(const MachineInstr *MI, // or , %lo(_GLOBAL_OFFSET_TABLE_+(-))), // add , %o7, - OutStreamer->EmitLabel(StartLabel); + OutStreamer->emitLabel(StartLabel); MCOperand Callee = createPCXCallOP(EndLabel, OutContext); EmitCall(*OutStreamer, Callee, STI); - OutStreamer->EmitLabel(SethiLabel); + OutStreamer->emitLabel(SethiLabel); MCOperand hiImm = createPCXRelExprOp(SparcMCExpr::VK_Sparc_PC22, GOTLabel, StartLabel, SethiLabel, OutContext); EmitSETHI(*OutStreamer, hiImm, MCRegOP, STI); - OutStreamer->EmitLabel(EndLabel); + OutStreamer->emitLabel(EndLabel); MCOperand loImm = createPCXRelExprOp(SparcMCExpr::VK_Sparc_PC10, GOTLabel, StartLabel, EndLabel, OutContext); diff --git a/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp b/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp index 4709bb6..8ad61dd 100644 --- a/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp +++ b/llvm/lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp @@ -1358,7 +1358,7 @@ SystemZAsmParser::parsePCRel(OperandVector &Operands, int64_t MinVal, } int64_t Value = CE->getValue(); MCSymbol *Sym = Ctx.createTempSymbol(); - Out.EmitLabel(Sym); + Out.emitLabel(Sym); const MCExpr *Base = MCSymbolRefExpr::create(Sym, MCSymbolRefExpr::VK_None, Ctx); Expr = Value == 0 ? Base : MCBinaryExpr::createAdd(Base, Expr, Ctx); diff --git a/llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp b/llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp index 954ebfc..c11598c 100644 --- a/llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp +++ b/llvm/lib/Target/SystemZ/SystemZAsmPrinter.cpp @@ -479,7 +479,7 @@ void SystemZAsmPrinter::emitInstruction(const MachineInstr *MI) { // that instead. case SystemZ::Trap: { MCSymbol *DotSym = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(DotSym); + OutStreamer->emitLabel(DotSym); const MCSymbolRefExpr *Expr = MCSymbolRefExpr::create(DotSym, OutContext); const MCConstantExpr *ConstExpr = MCConstantExpr::create(2, OutContext); @@ -492,7 +492,7 @@ void SystemZAsmPrinter::emitInstruction(const MachineInstr *MI) { // to the relative immediate field of the jump instruction. (eg. "jo .+2") case SystemZ::CondTrap: { MCSymbol *DotSym = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(DotSym); + OutStreamer->emitLabel(DotSym); const MCSymbolRefExpr *Expr = MCSymbolRefExpr::create(DotSym, OutContext); const MCConstantExpr *ConstExpr = MCConstantExpr::create(2, OutContext); @@ -544,7 +544,7 @@ static unsigned EmitNop(MCContext &OutContext, MCStreamer &OutStreamer, else { MCSymbol *DotSym = OutContext.createTempSymbol(); const MCSymbolRefExpr *Dot = MCSymbolRefExpr::create(DotSym, OutContext); - OutStreamer.EmitLabel(DotSym); + OutStreamer.emitLabel(DotSym); OutStreamer.emitInstruction( MCInstBuilder(SystemZ::BRCLAsm).addImm(0).addExpr(Dot), STI); return 6; @@ -559,9 +559,9 @@ void SystemZAsmPrinter::LowerFENTRY_CALL(const MachineInstr &MI, OutStreamer->PushSection(); OutStreamer->SwitchSection( Ctx.getELFSection("__mcount_loc", ELF::SHT_PROGBITS, ELF::SHF_ALLOC)); - OutStreamer->EmitSymbolValue(DotSym, 8); + OutStreamer->emitSymbolValue(DotSym, 8); OutStreamer->PopSection(); - OutStreamer->EmitLabel(DotSym); + OutStreamer->emitLabel(DotSym); } if (MF->getFunction().hasFnAttribute("mnop-mcount")) { @@ -585,7 +585,7 @@ void SystemZAsmPrinter::LowerSTACKMAP(const MachineInstr &MI) { auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordStackMap(*MILabel, MI); assert(NumNOPBytes % 2 == 0 && "Invalid number of NOP bytes requested!"); @@ -618,7 +618,7 @@ void SystemZAsmPrinter::LowerPATCHPOINT(const MachineInstr &MI, SystemZMCInstLower &Lower) { auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordPatchPoint(*MILabel, MI); PatchPointOpers Opers(&MI); diff --git a/llvm/lib/Target/TargetLoweringObjectFile.cpp b/llvm/lib/Target/TargetLoweringObjectFile.cpp index dcd3934..cfdb675 100644 --- a/llvm/lib/Target/TargetLoweringObjectFile.cpp +++ b/llvm/lib/Target/TargetLoweringObjectFile.cpp @@ -327,7 +327,7 @@ getTTypeReference(const MCSymbolRefExpr *Sym, unsigned Encoding, // Emit a label to the streamer for the current position. This gives us // .-foo addressing. MCSymbol *PCSym = getContext().createTempSymbol(); - Streamer.EmitLabel(PCSym); + Streamer.emitLabel(PCSym); const MCExpr *PC = MCSymbolRefExpr::create(PCSym, getContext()); return MCBinaryExpr::createSub(Sym, PC, getContext()); } diff --git a/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp b/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp index f655931..f595b72 100644 --- a/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp +++ b/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp @@ -894,7 +894,7 @@ public: // user. if (!LastFunctionLabel) return; auto TempSym = getContext().createLinkerPrivateTempSymbol(); - getStreamer().EmitLabel(TempSym); + getStreamer().emitLabel(TempSym); auto Start = MCSymbolRefExpr::create(LastFunctionLabel, getContext()); auto End = MCSymbolRefExpr::create(TempSym, getContext()); auto Expr = diff --git a/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp b/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp index f1647da..bd8c630 100644 --- a/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp +++ b/llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp @@ -3737,9 +3737,9 @@ bool X86AsmParser::parseDirectiveEven(SMLoc L) { Section = getStreamer().getCurrentSectionOnly(); } if (Section->UseCodeAlign()) - getStreamer().EmitCodeAlignment(2, 0); + getStreamer().emitCodeAlignment(2, 0); else - getStreamer().EmitValueToAlignment(2, 0, 1, 0); + getStreamer().emitValueToAlignment(2, 0, 1, 0); return false; } diff --git a/llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp b/llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp index d5494ef..862be62 100644 --- a/llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp +++ b/llvm/lib/Target/X86/MCTargetDesc/X86WinCOFFTargetStreamer.cpp @@ -159,7 +159,7 @@ bool X86WinCOFFTargetStreamer::checkInFPOPrologue(SMLoc L) { MCSymbol *X86WinCOFFTargetStreamer::emitFPOLabel() { MCSymbol *Label = getContext().createTempSymbol("cfi", true); - getStreamer().EmitLabel(Label); + getStreamer().emitLabel(Label); return Label; } @@ -400,7 +400,7 @@ bool X86WinCOFFTargetStreamer::emitFPOData(const MCSymbol *ProcSym, SMLoc L) { OS.EmitIntValue(unsigned(DebugSubsectionKind::FrameData), 4); OS.emitAbsoluteSymbolDiff(FrameEnd, FrameBegin, 4); - OS.EmitLabel(FrameBegin); + OS.emitLabel(FrameBegin); // Start with the RVA of the function in question. OS.EmitValue(MCSymbolRefExpr::create(FPO->Function, @@ -437,8 +437,8 @@ bool X86WinCOFFTargetStreamer::emitFPOData(const MCSymbol *ProcSym, SMLoc L) { FSM.emitFrameDataRecord(OS, Inst.Label); } - OS.EmitValueToAlignment(4, 0); - OS.EmitLabel(FrameEnd); + OS.emitValueToAlignment(4, 0); + OS.emitLabel(FrameEnd); return false; } diff --git a/llvm/lib/Target/X86/X86AsmPrinter.cpp b/llvm/lib/Target/X86/X86AsmPrinter.cpp index 494d5d2..18fb00c 100644 --- a/llvm/lib/Target/X86/X86AsmPrinter.cpp +++ b/llvm/lib/Target/X86/X86AsmPrinter.cpp @@ -656,7 +656,7 @@ static void emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel, MachineModuleInfoImpl::StubValueTy &MCSym) { // L_foo$stub: - OutStreamer.EmitLabel(StubLabel); + OutStreamer.emitLabel(StubLabel); // .indirect_symbol _foo OutStreamer.emitSymbolAttribute(MCSym.getPointer(), MCSA_IndirectSymbol); diff --git a/llvm/lib/Target/X86/X86MCInstLower.cpp b/llvm/lib/Target/X86/X86MCInstLower.cpp index 98f02a7..22333d0 100644 --- a/llvm/lib/Target/X86/X86MCInstLower.cpp +++ b/llvm/lib/Target/X86/X86MCInstLower.cpp @@ -1245,7 +1245,7 @@ void X86AsmPrinter::LowerSTATEPOINT(const MachineInstr &MI, // and PATCHPOINT auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordStatepoint(*MILabel, MI); } @@ -1265,7 +1265,7 @@ void X86AsmPrinter::LowerFAULTING_OP(const MachineInstr &FaultingMI, auto &Ctx = OutStreamer->getContext(); MCSymbol *FaultingLabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(FaultingLabel); + OutStreamer->emitLabel(FaultingLabel); assert(FK < FaultMaps::FaultKindMax && "Invalid Faulting Kind!"); FM.recordFaultingOp(FK, FaultingLabel, HandlerLabel); @@ -1345,7 +1345,7 @@ void X86AsmPrinter::LowerSTACKMAP(const MachineInstr &MI) { auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordStackMap(*MILabel, MI); unsigned NumShadowBytes = MI.getOperand(1).getImm(); @@ -1364,7 +1364,7 @@ void X86AsmPrinter::LowerPATCHPOINT(const MachineInstr &MI, auto &Ctx = OutStreamer->getContext(); MCSymbol *MILabel = Ctx.createTempSymbol(); - OutStreamer->EmitLabel(MILabel); + OutStreamer->emitLabel(MILabel); SM.recordPatchPoint(*MILabel, MI); PatchPointOpers opers(&MI); @@ -1445,8 +1445,8 @@ void X86AsmPrinter::LowerPATCHABLE_EVENT_CALL(const MachineInstr &MI, // First we emit the label and the jump. auto CurSled = OutContext.createTempSymbol("xray_event_sled_", true); OutStreamer->AddComment("# XRay Custom Event Log"); - OutStreamer->EmitCodeAlignment(2); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitCodeAlignment(2); + OutStreamer->emitLabel(CurSled); // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as // an operand (computed as an offset from the jmp instruction). @@ -1541,8 +1541,8 @@ void X86AsmPrinter::LowerPATCHABLE_TYPED_EVENT_CALL(const MachineInstr &MI, // First we emit the label and the jump. auto CurSled = OutContext.createTempSymbol("xray_typed_event_sled_", true); OutStreamer->AddComment("# XRay Typed Event Log"); - OutStreamer->EmitCodeAlignment(2); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitCodeAlignment(2); + OutStreamer->emitLabel(CurSled); // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as // an operand (computed as an offset from the jmp instruction). @@ -1643,8 +1643,8 @@ void X86AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI, // call // 5 bytes // auto CurSled = OutContext.createTempSymbol("xray_sled_", true); - OutStreamer->EmitCodeAlignment(2); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitCodeAlignment(2); + OutStreamer->emitLabel(CurSled); // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as // an operand (computed as an offset from the jmp instruction). @@ -1673,8 +1673,8 @@ void X86AsmPrinter::LowerPATCHABLE_RET(const MachineInstr &MI, // // This just makes sure that the alignment for the next instruction is 2. auto CurSled = OutContext.createTempSymbol("xray_sled_", true); - OutStreamer->EmitCodeAlignment(2); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitCodeAlignment(2); + OutStreamer->emitLabel(CurSled); unsigned OpCode = MI.getOperand(0).getImm(); MCInst Ret; Ret.setOpcode(OpCode); @@ -1697,8 +1697,8 @@ void X86AsmPrinter::LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI, // the PATCHABLE_FUNCTION_ENTER case, followed by the lowering of the actual // tail call much like how we have it in PATCHABLE_RET. auto CurSled = OutContext.createTempSymbol("xray_sled_", true); - OutStreamer->EmitCodeAlignment(2); - OutStreamer->EmitLabel(CurSled); + OutStreamer->emitCodeAlignment(2); + OutStreamer->emitLabel(CurSled); auto Target = OutContext.createTempSymbol(); // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as @@ -1706,7 +1706,7 @@ void X86AsmPrinter::LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI, // FIXME: Find another less hacky way do force the relative jump. OutStreamer->emitBytes("\xeb\x09"); EmitNops(*OutStreamer, 9, Subtarget->is64Bit(), getSubtargetInfo()); - OutStreamer->EmitLabel(Target); + OutStreamer->emitLabel(Target); recordSled(CurSled, MI, SledKind::TAIL_CALL); unsigned OpCode = MI.getOperand(0).getImm(); @@ -2018,7 +2018,7 @@ void X86AsmPrinter::emitInstruction(const MachineInstr *MI) { MCInstLowering.Lower(MI, Inst); EmitAndCountInstruction(Inst); CurrentPatchableFunctionEntrySym = createTempSymbol("patch"); - OutStreamer->EmitLabel(CurrentPatchableFunctionEntrySym); + OutStreamer->emitLabel(CurrentPatchableFunctionEntrySym); return; } break; @@ -2141,7 +2141,7 @@ void X86AsmPrinter::emitInstruction(const MachineInstr *MI) { } // Emit the label. - OutStreamer->EmitLabel(PICBase); + OutStreamer->emitLabel(PICBase); // popl $reg EmitAndCountInstruction( @@ -2166,7 +2166,7 @@ void X86AsmPrinter::emitInstruction(const MachineInstr *MI) { // However, we can't generate a ".", so just emit a new label here and refer // to it. MCSymbol *DotSym = OutContext.createTempSymbol(); - OutStreamer->EmitLabel(DotSym); + OutStreamer->emitLabel(DotSym); // Now that we have emitted the label, lower the complex operand expression. MCSymbol *OpSym = MCInstLowering.GetSymbolFromOperand(MI->getOperand(2)); diff --git a/llvm/lib/Target/XCore/XCoreAsmPrinter.cpp b/llvm/lib/Target/XCore/XCoreAsmPrinter.cpp index 3eb2679..7ad7e4a 100644 --- a/llvm/lib/Target/XCore/XCoreAsmPrinter.cpp +++ b/llvm/lib/Target/XCore/XCoreAsmPrinter.cpp @@ -152,7 +152,7 @@ void XCoreAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) { OutStreamer->emitSymbolAttribute(GVSym, MCSA_ELF_TypeObject); OutStreamer->emitELFSize(GVSym, MCConstantExpr::create(Size, OutContext)); } - OutStreamer->EmitLabel(GVSym); + OutStreamer->emitLabel(GVSym); emitGlobalConstant(DL, C); // The ABI requires that unsigned scalar types smaller than 32 bits @@ -178,7 +178,7 @@ void XCoreAsmPrinter::emitFunctionBodyEnd() { void XCoreAsmPrinter::emitFunctionEntryLabel() { // Mark the start of the function getTargetStreamer().emitCCTopFunction(CurrentFnSym->getName()); - OutStreamer->EmitLabel(CurrentFnSym); + OutStreamer->emitLabel(CurrentFnSym); } void XCoreAsmPrinter:: diff --git a/llvm/test/MC/RISCV/align.s b/llvm/test/MC/RISCV/align.s index c24df26..d378e3f 100644 --- a/llvm/test/MC/RISCV/align.s +++ b/llvm/test/MC/RISCV/align.s @@ -33,7 +33,7 @@ # Linker could satisfy alignment by removing NOPs after linker relaxation. # The first R_RISCV_ALIGN come from -# MCELFStreamer::InitSections() EmitCodeAlignment(4). +# MCELFStreamer::InitSections() emitCodeAlignment(4). # C-EXT-RELAX-RELOC: R_RISCV_ALIGN - 0x2 # C-EXT-RELAX-INST: c.nop test: diff --git a/llvm/tools/dsymutil/DwarfStreamer.cpp b/llvm/tools/dsymutil/DwarfStreamer.cpp index daaf606..d2f7715 100644 --- a/llvm/tools/dsymutil/DwarfStreamer.cpp +++ b/llvm/tools/dsymutil/DwarfStreamer.cpp @@ -158,7 +158,7 @@ void DwarfStreamer::emitCompileUnitHeader(CompileUnit &Unit) { /// The start of the unit within its section. Unit.setLabelBegin(Asm->createTempSymbol("cu_begin")); - Asm->OutStreamer->EmitLabel(Unit.getLabelBegin()); + Asm->OutStreamer->emitLabel(Unit.getLabelBegin()); // Emit size of content not including length itself. The size has already // been computed in CompileUnit::computeOffsets(). Subtract 4 to that size to @@ -270,7 +270,7 @@ void DwarfStreamer::emitAppleNamespaces( AccelTable &Table) { Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelNamespaceSection()); auto *SectionBegin = Asm->createTempSymbol("namespac_begin"); - Asm->OutStreamer->EmitLabel(SectionBegin); + Asm->OutStreamer->emitLabel(SectionBegin); emitAppleAccelTable(Asm.get(), Table, "namespac", SectionBegin); } @@ -278,7 +278,7 @@ void DwarfStreamer::emitAppleNames( AccelTable &Table) { Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelNamesSection()); auto *SectionBegin = Asm->createTempSymbol("names_begin"); - Asm->OutStreamer->EmitLabel(SectionBegin); + Asm->OutStreamer->emitLabel(SectionBegin); emitAppleAccelTable(Asm.get(), Table, "names", SectionBegin); } @@ -286,7 +286,7 @@ void DwarfStreamer::emitAppleObjc( AccelTable &Table) { Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelObjCSection()); auto *SectionBegin = Asm->createTempSymbol("objc_begin"); - Asm->OutStreamer->EmitLabel(SectionBegin); + Asm->OutStreamer->emitLabel(SectionBegin); emitAppleAccelTable(Asm.get(), Table, "objc", SectionBegin); } @@ -294,7 +294,7 @@ void DwarfStreamer::emitAppleTypes( AccelTable &Table) { Asm->OutStreamer->SwitchSection(MOFI->getDwarfAccelTypesSection()); auto *SectionBegin = Asm->createTempSymbol("types_begin"); - Asm->OutStreamer->EmitLabel(SectionBegin); + Asm->OutStreamer->emitLabel(SectionBegin); emitAppleAccelTable(Asm.get(), Table, "types", SectionBegin); } @@ -383,7 +383,7 @@ void DwarfStreamer::emitUnitRangesEntries(CompileUnit &Unit, unsigned Padding = offsetToAlignment(HeaderSize, Align(TupleSize)); Asm->emitLabelDifference(EndLabel, BeginLabel, 4); // Arange length - Asm->OutStreamer->EmitLabel(BeginLabel); + Asm->OutStreamer->emitLabel(BeginLabel); Asm->emitInt16(dwarf::DW_ARANGES_VERSION); // Version number Asm->emitInt32(Unit.getStartOffset()); // Corresponding unit's offset Asm->emitInt8(AddressSize); // Address size @@ -403,7 +403,7 @@ void DwarfStreamer::emitUnitRangesEntries(CompileUnit &Unit, // Emit terminator Asm->OutStreamer->EmitIntValue(0, AddressSize); Asm->OutStreamer->EmitIntValue(0, AddressSize); - Asm->OutStreamer->EmitLabel(EndLabel); + Asm->OutStreamer->emitLabel(EndLabel); } if (!DoDebugRanges) @@ -506,7 +506,7 @@ void DwarfStreamer::emitLineTableForUnit(MCDwarfLineTableParams Params, // The first 4 bytes is the total length of the information for this // compilation unit (not including these 4 bytes for the length). Asm->emitLabelDifference(LineEndSym, LineStartSym, 4); - Asm->OutStreamer->EmitLabel(LineStartSym); + Asm->OutStreamer->emitLabel(LineStartSym); // Copy Prologue. MS->emitBytes(PrologueBytes); LineSectionSize += PrologueBytes.size() + 4; @@ -521,7 +521,7 @@ void DwarfStreamer::emitLineTableForUnit(MCDwarfLineTableParams Params, EncodingOS); MS->emitBytes(EncodingOS.str()); LineSectionSize += EncodingBuffer.size(); - MS->EmitLabel(LineEndSym); + MS->emitLabel(LineEndSym); return; } @@ -636,7 +636,7 @@ void DwarfStreamer::emitLineTableForUnit(MCDwarfLineTableParams Params, EncodingBuffer.resize(0); } - MS->EmitLabel(LineEndSym); + MS->emitLabel(LineEndSym); } /// Copy the debug_line over to the updated binary while unobfuscating the file @@ -661,14 +661,14 @@ void DwarfStreamer::translateLineTable(DataExtractor Data, uint64_t Offset) { } Asm->emitLabelDifference(EndLabel, BeginLabel, 4); - Asm->OutStreamer->EmitLabel(BeginLabel); + Asm->OutStreamer->emitLabel(BeginLabel); Asm->emitInt16(Version); LineSectionSize += 6; MCSymbol *HeaderBeginLabel = MC->createTempSymbol(); MCSymbol *HeaderEndLabel = MC->createTempSymbol(); Asm->emitLabelDifference(HeaderEndLabel, HeaderBeginLabel, 4); - Asm->OutStreamer->EmitLabel(HeaderBeginLabel); + Asm->OutStreamer->emitLabel(HeaderBeginLabel); Offset += 4; LineSectionSize += 4; @@ -711,13 +711,13 @@ void DwarfStreamer::translateLineTable(DataExtractor Data, uint64_t Offset) { Asm->emitInt8(0); LineSectionSize += 1; - Asm->OutStreamer->EmitLabel(HeaderEndLabel); + Asm->OutStreamer->emitLabel(HeaderEndLabel); // Copy the actual line table program over. Asm->OutStreamer->emitBytes(Contents.slice(Offset, UnitEnd)); LineSectionSize += UnitEnd - Offset; - Asm->OutStreamer->EmitLabel(EndLabel); + Asm->OutStreamer->emitLabel(EndLabel); Offset = UnitEnd; } @@ -762,7 +762,7 @@ void DwarfStreamer::emitPubSectionForUnit( if (!HeaderEmitted) { // Emit the header. Asm->emitLabelDifference(EndLabel, BeginLabel, 4); // Length - Asm->OutStreamer->EmitLabel(BeginLabel); + Asm->OutStreamer->emitLabel(BeginLabel); Asm->emitInt16(dwarf::DW_PUBNAMES_VERSION); // Version Asm->emitInt32(Unit.getStartOffset()); // Unit offset Asm->emitInt32(Unit.getNextUnitOffset() - Unit.getStartOffset()); // Size @@ -779,7 +779,7 @@ void DwarfStreamer::emitPubSectionForUnit( if (!HeaderEmitted) return; Asm->emitInt32(0); // End marker. - Asm->OutStreamer->EmitLabel(EndLabel); + Asm->OutStreamer->emitLabel(EndLabel); } /// Emit .debug_pubnames for \p Unit. diff --git a/llvm/tools/llvm-exegesis/lib/SnippetFile.cpp b/llvm/tools/llvm-exegesis/lib/SnippetFile.cpp index a41e7aa..c71050c 100644 --- a/llvm/tools/llvm-exegesis/lib/SnippetFile.cpp +++ b/llvm/tools/llvm-exegesis/lib/SnippetFile.cpp @@ -92,7 +92,7 @@ private: bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override { return false; } - void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, + void emitValueToAlignment(unsigned ByteAlignment, int64_t Value, unsigned ValueSize, unsigned MaxBytesToEmit) override {} void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size, diff --git a/llvm/tools/llvm-mca/CodeRegionGenerator.cpp b/llvm/tools/llvm-mca/CodeRegionGenerator.cpp index 08cb18e..831b76ab 100644 --- a/llvm/tools/llvm-mca/CodeRegionGenerator.cpp +++ b/llvm/tools/llvm-mca/CodeRegionGenerator.cpp @@ -61,7 +61,7 @@ public: void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr, uint64_t Size = 0, unsigned ByteAlignment = 0, SMLoc Loc = SMLoc()) override {} - void EmitGPRel32Value(const MCExpr *Value) override {} + void emitGPRel32Value(const MCExpr *Value) override {} void BeginCOFFSymbolDef(const MCSymbol *Symbol) override {} void EmitCOFFSymbolStorageClass(int StorageClass) override {} void EmitCOFFSymbolType(int Type) override {} diff --git a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp index 301088f..3aa0621 100644 --- a/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp +++ b/llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp @@ -236,7 +236,7 @@ void dwarfgen::LineTable::generate(MCContext &MC, AsmPrinter &Asm) const { writeData(Contents, Asm); if (EndSymbol != nullptr) - Asm.OutStreamer->EmitLabel(EndSymbol); + Asm.OutStreamer->emitLabel(EndSymbol); } void dwarfgen::LineTable::writeData(ArrayRef Data, @@ -287,7 +287,7 @@ MCSymbol *dwarfgen::LineTable::writeDefaultPrologue(AsmPrinter &Asm) const { } else { Asm.emitLabelDifference(UnitEnd, UnitStart, 4); } - Asm.OutStreamer->EmitLabel(UnitStart); + Asm.OutStreamer->emitLabel(UnitStart); Asm.emitInt16(Version); if (Version == 5) { Asm.emitInt8(AddrSize); @@ -298,11 +298,11 @@ MCSymbol *dwarfgen::LineTable::writeDefaultPrologue(AsmPrinter &Asm) const { MCSymbol *PrologueEnd = Asm.createTempSymbol("line_prologue_end"); Asm.emitLabelDifference(PrologueEnd, PrologueStart, Format == DwarfFormat::DWARF64 ? 8 : 4); - Asm.OutStreamer->EmitLabel(PrologueStart); + Asm.OutStreamer->emitLabel(PrologueStart); DWARFDebugLine::Prologue DefaultPrologue = createBasicPrologue(); writeProloguePayload(DefaultPrologue, Asm); - Asm.OutStreamer->EmitLabel(PrologueEnd); + Asm.OutStreamer->emitLabel(PrologueEnd); return UnitEnd; } -- 2.7.4