RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 20:23:11 +01:00
Code Issues Projects Releases Wiki Activity

[AsmPrinter] De-capitalize Emit{Function,BasicBlock]* and Emit{Start,End}OfAsmFile

Browse Source
This commit is contained in:
Fangrui Song 2020-02-13 13:10:49 -08:00
parent a6ea471ba2
commit 2357c0bf62
27 changed files with 134 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
include/llvm/CodeGen/AsmPrinter.h
View File

@ -319,7 +319,7 @@ public:
/// Emit the specified function out to the OutStreamer.
bool runOnMachineFunction(MachineFunction &MF) override {
SetupMachineFunction(MF);
EmitFunctionBody();
emitFunctionBody();
return false;
}
@ -332,7 +332,7 @@ public:
virtual void SetupMachineFunction(MachineFunction &MF);
/// This method emits the body and trailer for a function.
void EmitFunctionBody();
void emitFunctionBody();
void emitCFIInstruction(const MachineInstr &MI);
@ -406,28 +406,28 @@ public:
/// This virtual method can be overridden by targets that want to emit
/// something at the start of their file.
virtual void EmitStartOfAsmFile(Module &) {}
virtual void emitStartOfAsmFile(Module &) {}
/// This virtual method can be overridden by targets that want to emit
/// something at the end of their file.
virtual void EmitEndOfAsmFile(Module &) {}
virtual void emitEndOfAsmFile(Module &) {}
/// Targets can override this to emit stuff before the first basic block in
/// the function.
virtual void EmitFunctionBodyStart() {}
virtual void emitFunctionBodyStart() {}
/// Targets can override this to emit stuff after the last basic block in the
/// function.
virtual void EmitFunctionBodyEnd() {}
virtual void emitFunctionBodyEnd() {}
/// Targets can override this to emit stuff at the start of a basic block.
/// By default, this method prints the label for the specified
/// MachineBasicBlock, an alignment (if present) and a comment describing it
/// if appropriate.
virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB);
virtual void emitBasicBlockStart(const MachineBasicBlock &MBB);
/// Targets can override this to emit stuff at the end of a basic block.
virtual void EmitBasicBlockEnd(const MachineBasicBlock &MBB);
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB);
/// Targets should implement this to emit instructions.
virtual void EmitInstruction(const MachineInstr *) {
@ -437,9 +437,9 @@ public:
/// Return the symbol for the specified constant pool entry.
virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
virtual void EmitFunctionEntryLabel();
virtual void emitFunctionEntryLabel();
virtual void EmitFunctionDescriptor() {
virtual void emitFunctionDescriptor() {
llvm_unreachable("Function descriptor is target-specific.");
}
@ -678,7 +678,7 @@ private:
mutable unsigned Counter = ~0U;
/// This method emits the header for the current function.
virtual void EmitFunctionHeader();
virtual void emitFunctionHeader();
/// Emit a blob of inline asm to the output streamer.
void

2
include/llvm/CodeGen/SelectionDAGISel.h
View File

@ -78,7 +78,7 @@ public:
bool runOnMachineFunction(MachineFunction &MF) override;
virtual void EmitFunctionEntryCode() {}
virtual void emitFunctionEntryCode() {}
/// PreprocessISelDAG - This hook allows targets to hack on the graph before
/// instruction selection starts.

28
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -280,7 +280,7 @@ bool AsmPrinter::doInitialization(Module &M) {
OutStreamer->EmitVersionForTarget(Target, M.getSDKVersion());
// Allow the target to emit any magic that it wants at the start of the file.
EmitStartOfAsmFile(M);
emitStartOfAsmFile(M);
// Very minimal debug info. It is ignored if we emit actual debug info. If we
// don't, this at least helps the user find where a global came from.
@ -670,7 +670,7 @@ void AsmPrinter::EmitDebugValue(const MCExpr *Value, unsigned Size) const {
/// EmitFunctionHeader - This method emits the header for the current
/// function.
void AsmPrinter::EmitFunctionHeader() {
void AsmPrinter::emitFunctionHeader() {
const Function &F = MF->getFunction();
if (isVerbose())
@ -750,11 +750,11 @@ void AsmPrinter::EmitFunctionHeader() {
// the AIX target. The PowerPC 64-bit V1 ELF target also uses function
// descriptors and should be converted to use this hook as well.
if (MAI->needsFunctionDescriptors())
EmitFunctionDescriptor();
emitFunctionDescriptor();
// Emit the CurrentFnSym. This is a virtual function to allow targets to do
// their wild and crazy things as required.
EmitFunctionEntryLabel();
emitFunctionEntryLabel();
if (CurrentFnBegin) {
if (MAI->useAssignmentForEHBegin()) {
@ -781,7 +781,7 @@ void AsmPrinter::EmitFunctionHeader() {
/// EmitFunctionEntryLabel - Emit the label that is the entrypoint for the
/// function. This can be overridden by targets as required to do custom stuff.
void AsmPrinter::EmitFunctionEntryLabel() {
void AsmPrinter::emitFunctionEntryLabel() {
CurrentFnSym->redefineIfPossible();
// The function label could have already been emitted if two symbols end up
@ -1066,11 +1066,11 @@ static bool needFuncLabelsForEHOrDebugInfo(const MachineFunction &MF,
/// EmitFunctionBody - This method emits the body and trailer for a
/// function.
void AsmPrinter::EmitFunctionBody() {
EmitFunctionHeader();
void AsmPrinter::emitFunctionBody() {
emitFunctionHeader();
// Emit target-specific gunk before the function body.
EmitFunctionBodyStart();
emitFunctionBodyStart();
bool ShouldPrintDebugScopes = MMI->hasDebugInfo();
@ -1097,7 +1097,7 @@ void AsmPrinter::EmitFunctionBody() {
int NumInstsInFunction = 0;
for (auto &MBB : *MF) {
// Print a label for the basic block.
EmitBasicBlockStart(MBB);
emitBasicBlockStart(MBB);
for (auto &MI : MBB) {
// Print the assembly for the instruction.
if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() &&
@ -1175,7 +1175,7 @@ void AsmPrinter::EmitFunctionBody() {
}
}
EmitBasicBlockEnd(MBB);
emitBasicBlockEnd(MBB);
}
EmittedInsts += NumInstsInFunction;
@ -1220,7 +1220,7 @@ void AsmPrinter::EmitFunctionBody() {
}
// Emit target-specific gunk after the function body.
EmitFunctionBodyEnd();
emitFunctionBodyEnd();
if (needFuncLabelsForEHOrDebugInfo(*MF, MMI) ||
MAI->hasDotTypeDotSizeDirective()) {
@ -1682,7 +1682,7 @@ bool AsmPrinter::doFinalization(Module &M) {
// Allow the target to emit any magic that it wants at the end of the file,
// after everything else has gone out.
EmitEndOfAsmFile(M);
emitEndOfAsmFile(M);
MMI = nullptr;
@ -2981,7 +2981,7 @@ static void emitBasicBlockLoopComments(const MachineBasicBlock &MBB,
/// EmitBasicBlockStart - This method prints the label for the specified
/// MachineBasicBlock, an alignment (if present) and a comment describing
/// it if appropriate.
void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
void AsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) {
// End the previous funclet and start a new one.
if (MBB.isEHFuncletEntry()) {
for (const HandlerInfo &HI : Handlers) {
@ -3041,7 +3041,7 @@ void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
}
}
void AsmPrinter::EmitBasicBlockEnd(const MachineBasicBlock &MBB) {}
void AsmPrinter::emitBasicBlockEnd(const MachineBasicBlock &MBB) {}
void AsmPrinter::EmitVisibility(MCSymbol *Sym, unsigned Visibility,
bool IsDefinition) const {

2
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -9982,7 +9982,7 @@ void SelectionDAGISel::LowerArguments(const Function &F) {
}
// Finally, if the target has anything special to do, allow it to do so.
EmitFunctionEntryCode();
emitFunctionEntryCode();
}
/// Handle PHI nodes in successor blocks. Emit code into the SelectionDAG to

14
lib/Target/AArch64/AArch64AsmPrinter.cpp
View File

@ -84,7 +84,7 @@ public:
return MCInstLowering.lowerOperand(MO, MCOp);
}
void EmitStartOfAsmFile(Module &M) override;
void emitStartOfAsmFile(Module &M) override;
void EmitJumpTableInfo() override;
void emitJumpTableEntry(const MachineJumpTableInfo *MJTI,
const MachineBasicBlock *MBB, unsigned JTI);
@ -139,7 +139,7 @@ public:
}
// Emit the rest of the function body.
EmitFunctionBody();
emitFunctionBody();
// Emit the XRay table for this function.
emitXRayTable();
@ -162,10 +162,10 @@ private:
void PrintDebugValueComment(const MachineInstr *MI, raw_ostream &OS);
void EmitFunctionBodyEnd() override;
void emitFunctionBodyEnd() override;
MCSymbol *GetCPISymbol(unsigned CPID) const override;
void EmitEndOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
AArch64FunctionInfo *AArch64FI = nullptr;
@ -182,7 +182,7 @@ private:
} // end anonymous namespace
void AArch64AsmPrinter::EmitStartOfAsmFile(Module &M) {
void AArch64AsmPrinter::emitStartOfAsmFile(Module &M) {
if (!TM.getTargetTriple().isOSBinFormatELF())
return;
@ -518,7 +518,7 @@ void AArch64AsmPrinter::EmitHwasanMemaccessSymbols(Module &M) {
}
}
void AArch64AsmPrinter::EmitEndOfAsmFile(Module &M) {
void AArch64AsmPrinter::emitEndOfAsmFile(Module &M) {
EmitHwasanMemaccessSymbols(M);
const Triple &TT = TM.getTargetTriple();
@ -548,7 +548,7 @@ void AArch64AsmPrinter::EmitLOHs() {
}
}
void AArch64AsmPrinter::EmitFunctionBodyEnd() {
void AArch64AsmPrinter::emitFunctionBodyEnd() {
if (!AArch64FI->getLOHRelated().empty())
EmitLOHs();
}

20
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
View File

@ -112,7 +112,7 @@ AMDGPUTargetStreamer* AMDGPUAsmPrinter::getTargetStreamer() const {
return static_cast<AMDGPUTargetStreamer*>(OutStreamer->getTargetStreamer());
}
void AMDGPUAsmPrinter::EmitStartOfAsmFile(Module &M) {
void AMDGPUAsmPrinter::emitStartOfAsmFile(Module &M) {
if (IsaInfo::hasCodeObjectV3(getGlobalSTI())) {
std::string ExpectedTarget;
raw_string_ostream ExpectedTargetOS(ExpectedTarget);
@ -144,7 +144,7 @@ void AMDGPUAsmPrinter::EmitStartOfAsmFile(Module &M) {
Version.Major, Version.Minor, Version.Stepping, "AMD", "AMDGPU");
}
void AMDGPUAsmPrinter::EmitEndOfAsmFile(Module &M) {
void AMDGPUAsmPrinter::emitEndOfAsmFile(Module &M) {
// Following code requires TargetStreamer to be present.
if (!getTargetStreamer())
return;
@ -180,7 +180,7 @@ bool AMDGPUAsmPrinter::isBlockOnlyReachableByFallthrough(
return (MBB->back().getOpcode() != AMDGPU::S_SETPC_B64);
}
void AMDGPUAsmPrinter::EmitFunctionBodyStart() {
void AMDGPUAsmPrinter::emitFunctionBodyStart() {
const SIMachineFunctionInfo &MFI = *MF->getInfo<SIMachineFunctionInfo>();
if (!MFI.isEntryFunction())
return;
@ -199,7 +199,7 @@ void AMDGPUAsmPrinter::EmitFunctionBodyStart() {
HSAMetadataStream->emitKernel(*MF, CurrentProgramInfo);
}
void AMDGPUAsmPrinter::EmitFunctionBodyEnd() {
void AMDGPUAsmPrinter::emitFunctionBodyEnd() {
const SIMachineFunctionInfo &MFI = *MF->getInfo<SIMachineFunctionInfo>();
if (!MFI.isEntryFunction())
return;
@ -239,10 +239,10 @@ void AMDGPUAsmPrinter::EmitFunctionBodyEnd() {
Streamer.PopSection();
}
void AMDGPUAsmPrinter::EmitFunctionEntryLabel() {
void AMDGPUAsmPrinter::emitFunctionEntryLabel() {
if (IsaInfo::hasCodeObjectV3(getGlobalSTI()) &&
TM.getTargetTriple().getOS() == Triple::AMDHSA) {
AsmPrinter::EmitFunctionEntryLabel();
AsmPrinter::emitFunctionEntryLabel();
return;
}
@ -261,10 +261,10 @@ void AMDGPUAsmPrinter::EmitFunctionEntryLabel() {
HexLines.push_back("");
}
AsmPrinter::EmitFunctionEntryLabel();
AsmPrinter::emitFunctionEntryLabel();
}
void AMDGPUAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
void AMDGPUAsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) {
if (DumpCodeInstEmitter && !isBlockOnlyReachableByFallthrough(&MBB)) {
// Write a line for the basic block label if it is not only fallthrough.
DisasmLines.push_back(
@ -273,7 +273,7 @@ void AMDGPUAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
DisasmLineMaxLen = std::max(DisasmLineMaxLen, DisasmLines.back().size());
HexLines.push_back("");
}
AsmPrinter::EmitBasicBlockStart(MBB);
AsmPrinter::emitBasicBlockStart(MBB);
}
void AMDGPUAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
@ -460,7 +460,7 @@ bool AMDGPUAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
HexLines.clear();
DisasmLineMaxLen = 0;
EmitFunctionBody();
emitFunctionBody();
if (isVerbose()) {
MCSectionELF *CommentSection =

12
lib/Target/AMDGPU/AMDGPUAsmPrinter.h
View File

@ -123,19 +123,19 @@ public:
/// Implemented in AMDGPUMCInstLower.cpp
void EmitInstruction(const MachineInstr *MI) override;
void EmitFunctionBodyStart() override;
void emitFunctionBodyStart() override;
void EmitFunctionBodyEnd() override;
void emitFunctionBodyEnd() override;
void EmitFunctionEntryLabel() override;
void emitFunctionEntryLabel() override;
void EmitBasicBlockStart(const MachineBasicBlock &MBB) override;
void emitBasicBlockStart(const MachineBasicBlock &MBB) override;
void EmitGlobalVariable(const GlobalVariable *GV) override;
void EmitStartOfAsmFile(Module &M) override;
void emitStartOfAsmFile(Module &M) override;
void EmitEndOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
bool isBlockOnlyReachableByFallthrough(
const MachineBasicBlock *MBB) const override;

2
lib/Target/AMDGPU/R600AsmPrinter.cpp
View File

@ -115,7 +115,7 @@ bool R600AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
EmitProgramInfoR600(MF);
EmitFunctionBody();
emitFunctionBody();
if (isVerbose()) {
MCSectionELF *CommentSection =

12
lib/Target/ARM/ARMAsmPrinter.cpp
View File

@ -57,7 +57,7 @@ ARMAsmPrinter::ARMAsmPrinter(TargetMachine &TM,
: AsmPrinter(TM, std::move(Streamer)), Subtarget(nullptr), AFI(nullptr),
MCP(nullptr), InConstantPool(false), OptimizationGoals(-1) {}
void ARMAsmPrinter::EmitFunctionBodyEnd() {
void ARMAsmPrinter::emitFunctionBodyEnd() {
// Make sure to terminate any constant pools that were at the end
// of the function.
if (!InConstantPool)
@ -66,7 +66,7 @@ void ARMAsmPrinter::EmitFunctionBodyEnd() {
OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
}
void ARMAsmPrinter::EmitFunctionEntryLabel() {
void ARMAsmPrinter::emitFunctionEntryLabel() {
if (AFI->isThumbFunction()) {
OutStreamer->EmitAssemblerFlag(MCAF_Code16);
OutStreamer->EmitThumbFunc(CurrentFnSym);
@ -158,7 +158,7 @@ bool ARMAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
}
// Emit the rest of the function body.
EmitFunctionBody();
emitFunctionBody();
// Emit the XRay table for this function.
emitXRayTable();
@ -471,7 +471,7 @@ void ARMAsmPrinter::emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
}
}
void ARMAsmPrinter::EmitStartOfAsmFile(Module &M) {
void ARMAsmPrinter::emitStartOfAsmFile(Module &M) {
const Triple &TT = TM.getTargetTriple();
// Use unified assembler syntax.
OutStreamer->EmitAssemblerFlag(MCAF_SyntaxUnified);
@ -511,7 +511,7 @@ emitNonLazySymbolPointer(MCStreamer &OutStreamer, MCSymbol *StubLabel,
}
void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
void ARMAsmPrinter::emitEndOfAsmFile(Module &M) {
const Triple &TT = TM.getTargetTriple();
if (TT.isOSBinFormatMachO()) {
// All darwin targets use mach-o.
@ -570,7 +570,7 @@ void ARMAsmPrinter::EmitEndOfAsmFile(Module &M) {
}
//===----------------------------------------------------------------------===//
// Helper routines for EmitStartOfAsmFile() and EmitEndOfAsmFile()
// Helper routines for emitStartOfAsmFile() and emitEndOfAsmFile()
// FIXME:
// The following seem like one-off assembler flags, but they actually need
// to appear in the .ARM.attributes section in ELF.

10
lib/Target/ARM/ARMAsmPrinter.h
View File

@ -93,10 +93,10 @@ public:
void EmitConstantPool() override {
// we emit constant pools customly!
}
void EmitFunctionBodyEnd() override;
void EmitFunctionEntryLabel() override;
void EmitStartOfAsmFile(Module &M) override;
void EmitEndOfAsmFile(Module &M) override;
void emitFunctionBodyEnd() override;
void emitFunctionEntryLabel() override;
void emitStartOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
void EmitXXStructor(const DataLayout &DL, const Constant *CV) override;
void EmitGlobalVariable(const GlobalVariable *GV) override;
@ -117,7 +117,7 @@ public:
private:
void EmitSled(const MachineInstr &MI, SledKind Kind);
// Helpers for EmitStartOfAsmFile() and EmitEndOfAsmFile()
// Helpers for emitStartOfAsmFile() and emitEndOfAsmFile()
void emitAttributes();
// Generic helper used to emit e.g. ARMv5 mul pseudos

2
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
View File

@ -1275,7 +1275,7 @@ void HexagonDAGToDAGISel::PreprocessISelDAG() {
}
}
void HexagonDAGToDAGISel::EmitFunctionEntryCode() {
void HexagonDAGToDAGISel::emitFunctionEntryCode() {
auto &HST = MF->getSubtarget<HexagonSubtarget>();
auto &HFI = *HST.getFrameLowering();
if (!HFI.needsAligna(*MF))

2
lib/Target/Hexagon/HexagonISelDAGToDAG.h
View File

@ -51,7 +51,7 @@ public:
return true;
}
void PreprocessISelDAG() override;
void EmitFunctionEntryCode() override;
void emitFunctionEntryCode() override;
void Select(SDNode *N) override;

2
lib/Target/MSP430/MSP430AsmPrinter.cpp
View File

@ -180,7 +180,7 @@ bool MSP430AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
}
SetupMachineFunction(MF);
EmitFunctionBody();
emitFunctionBody();
return false;
}

14
lib/Target/Mips/MipsAsmPrinter.cpp
View File

@ -398,7 +398,7 @@ const char *MipsAsmPrinter::getCurrentABIString() const {
}
}
void MipsAsmPrinter::EmitFunctionEntryLabel() {
void MipsAsmPrinter::emitFunctionEntryLabel() {
MipsTargetStreamer &TS = getTargetStreamer();
// NaCl sandboxing requires that indirect call instructions are masked.
@ -424,7 +424,7 @@ void MipsAsmPrinter::EmitFunctionEntryLabel() {
/// EmitFunctionBodyStart - Targets can override this to emit stuff before
/// the first basic block in the function.
void MipsAsmPrinter::EmitFunctionBodyStart() {
void MipsAsmPrinter::emitFunctionBodyStart() {
MipsTargetStreamer &TS = getTargetStreamer();
MCInstLowering.Initialize(&MF->getContext());
@ -445,7 +445,7 @@ void MipsAsmPrinter::EmitFunctionBodyStart() {
/// EmitFunctionBodyEnd - Targets can override this to emit stuff after
/// the last basic block in the function.
void MipsAsmPrinter::EmitFunctionBodyEnd() {
void MipsAsmPrinter::emitFunctionBodyEnd() {
MipsTargetStreamer &TS = getTargetStreamer();
// There are instruction for this macros, but they must
@ -465,8 +465,8 @@ void MipsAsmPrinter::EmitFunctionBodyEnd() {
OutStreamer->EmitDataRegion(MCDR_DataRegionEnd);
}
void MipsAsmPrinter::EmitBasicBlockEnd(const MachineBasicBlock &MBB) {
AsmPrinter::EmitBasicBlockEnd(MBB);
void MipsAsmPrinter::emitBasicBlockEnd(const MachineBasicBlock &MBB) {
AsmPrinter::emitBasicBlockEnd(MBB);
MipsTargetStreamer &TS = getTargetStreamer();
if (MBB.empty())
TS.emitDirectiveInsn();
@ -770,7 +770,7 @@ printRegisterList(const MachineInstr *MI, int opNum, raw_ostream &O) {
}
}
void MipsAsmPrinter::EmitStartOfAsmFile(Module &M) {
void MipsAsmPrinter::emitStartOfAsmFile(Module &M) {
MipsTargetStreamer &TS = getTargetStreamer();
// MipsTargetStreamer has an initialization order problem when emitting an
@ -1122,7 +1122,7 @@ void MipsAsmPrinter::EmitFPCallStub(
OutStreamer->PopSection();
}
void MipsAsmPrinter::EmitEndOfAsmFile(Module &M) {
void MipsAsmPrinter::emitEndOfAsmFile(Module &M) {
// Emit needed stubs
//
for (std::map<

12
lib/Target/Mips/MipsAsmPrinter.h
View File

@ -138,10 +138,10 @@ public:
void printSavedRegsBitmask();
void emitFrameDirective();
const char *getCurrentABIString() const;
void EmitFunctionEntryLabel() override;
void EmitFunctionBodyStart() override;
void EmitFunctionBodyEnd() override;
void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override;
void emitFunctionEntryLabel() override;
void emitFunctionBodyStart() override;
void emitFunctionBodyEnd() override;
void emitBasicBlockEnd(const MachineBasicBlock &MBB) override;
bool isBlockOnlyReachableByFallthrough(
const MachineBasicBlock* MBB) const override;
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
@ -154,8 +154,8 @@ public:
void printFCCOperand(const MachineInstr *MI, int opNum, raw_ostream &O,
const char *Modifier = nullptr);
void printRegisterList(const MachineInstr *MI, int opNum, raw_ostream &O);
void EmitStartOfAsmFile(Module &M) override;
void EmitEndOfAsmFile(Module &M) override;
void emitStartOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
void PrintDebugValueComment(const MachineInstr *MI, raw_ostream &OS);
void EmitDebugValue(const MCExpr *Value, unsigned Size) const override;
};

10
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
View File

@ -434,13 +434,13 @@ bool NVPTXAsmPrinter::isLoopHeaderOfNoUnroll(
return false;
}
void NVPTXAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
AsmPrinter::EmitBasicBlockStart(MBB);
void NVPTXAsmPrinter::emitBasicBlockStart(const MachineBasicBlock &MBB) {
AsmPrinter::emitBasicBlockStart(MBB);
if (isLoopHeaderOfNoUnroll(MBB))
OutStreamer->EmitRawText(StringRef("\t.pragma \"nounroll\";\n"));
}
void NVPTXAsmPrinter::EmitFunctionEntryLabel() {
void NVPTXAsmPrinter::emitFunctionEntryLabel() {
SmallString<128> Str;
raw_svector_ostream O(Str);
@ -489,14 +489,14 @@ bool NVPTXAsmPrinter::runOnMachineFunction(MachineFunction &F) {
return Result;
}
void NVPTXAsmPrinter::EmitFunctionBodyStart() {
void NVPTXAsmPrinter::emitFunctionBodyStart() {
SmallString<128> Str;
raw_svector_ostream O(Str);
emitDemotedVars(&MF->getFunction(), O);
OutStreamer->EmitRawText(O.str());
}
void NVPTXAsmPrinter::EmitFunctionBodyEnd() {
void NVPTXAsmPrinter::emitFunctionBodyEnd() {
VRegMapping.clear();
}

8
lib/Target/NVPTX/NVPTXAsmPrinter.h
View File

@ -200,10 +200,10 @@ private:
const Function *F;
std::string CurrentFnName;
void EmitBasicBlockStart(const MachineBasicBlock &MBB) override;
void EmitFunctionEntryLabel() override;
void EmitFunctionBodyStart() override;
void EmitFunctionBodyEnd() override;
void emitBasicBlockStart(const MachineBasicBlock &MBB) override;
void emitFunctionEntryLabel() override;
void emitFunctionBodyStart() override;
void emitFunctionBodyEnd() override;
void emitImplicitDef(const MachineInstr *MI) const override;
void EmitInstruction(const MachineInstr *) override;

38
lib/Target/PowerPC/PPCAsmPrinter.cpp
View File

@ -113,7 +113,7 @@ public:
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode, raw_ostream &O) override;
void EmitEndOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
void LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI);
void LowerPATCHPOINT(StackMaps &SM, const MachineInstr &MI);
@ -138,12 +138,12 @@ public:
}
bool doFinalization(Module &M) override;
void EmitStartOfAsmFile(Module &M) override;
void emitStartOfAsmFile(Module &M) override;
void EmitFunctionEntryLabel() override;
void emitFunctionEntryLabel() override;
void EmitFunctionBodyStart() override;
void EmitFunctionBodyEnd() override;
void emitFunctionBodyStart() override;
void emitFunctionBodyEnd() override;
void EmitInstruction(const MachineInstr *MI) override;
};
@ -165,9 +165,9 @@ public:
void EmitGlobalVariable(const GlobalVariable *GV) override;
void EmitFunctionDescriptor() override;
void emitFunctionDescriptor() override;
void EmitEndOfAsmFile(Module &) override;
void emitEndOfAsmFile(Module &) override;
};
} // end anonymous namespace
@ -317,7 +317,7 @@ MCSymbol *PPCAsmPrinter::lookUpOrCreateTOCEntry(const MCSymbol *Sym) {
return TOCEntry;
}
void PPCAsmPrinter::EmitEndOfAsmFile(Module &M) {
void PPCAsmPrinter::emitEndOfAsmFile(Module &M) {
emitStackMaps(SM);
}
@ -1287,7 +1287,7 @@ void PPCLinuxAsmPrinter::EmitInstruction(const MachineInstr *MI) {
}
}
void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
void PPCLinuxAsmPrinter::emitStartOfAsmFile(Module &M) {
if (static_cast<const PPCTargetMachine &>(TM).isELFv2ABI()) {
PPCTargetStreamer *TS =
static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
@ -1298,10 +1298,10 @@ void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
if (static_cast<const PPCTargetMachine &>(TM).isPPC64() ||
!isPositionIndependent())
return AsmPrinter::EmitStartOfAsmFile(M);
return AsmPrinter::emitStartOfAsmFile(M);
if (M.getPICLevel() == PICLevel::SmallPIC)
return AsmPrinter::EmitStartOfAsmFile(M);
return AsmPrinter::emitStartOfAsmFile(M);
OutStreamer->SwitchSection(OutContext.getELFSection(
".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC));
@ -1323,12 +1323,12 @@ void PPCLinuxAsmPrinter::EmitStartOfAsmFile(Module &M) {
OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
}
void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
void PPCLinuxAsmPrinter::emitFunctionEntryLabel() {
// linux/ppc32 - Normal entry label.
if (!Subtarget->isPPC64() &&
(!isPositionIndependent() ||
MF->getFunction().getParent()->getPICLevel() == PICLevel::SmallPIC))
return AsmPrinter::EmitFunctionEntryLabel();
return AsmPrinter::emitFunctionEntryLabel();
if (!Subtarget->isPPC64()) {
const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
@ -1347,7 +1347,7 @@ void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
OutStreamer->EmitLabel(CurrentFnSym);
return;
} else
return AsmPrinter::EmitFunctionEntryLabel();
return AsmPrinter::emitFunctionEntryLabel();
}
// ELFv2 ABI - Normal entry label.
@ -1371,7 +1371,7 @@ void PPCLinuxAsmPrinter::EmitFunctionEntryLabel() {
OutStreamer->EmitLabel(PPCFI->getTOCOffsetSymbol());
OutStreamer->EmitValue(TOCDeltaExpr, 8);
}
return AsmPrinter::EmitFunctionEntryLabel();
return AsmPrinter::emitFunctionEntryLabel();
}
// Emit an official procedure descriptor.
@ -1433,7 +1433,7 @@ bool PPCLinuxAsmPrinter::doFinalization(Module &M) {
}
/// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
void PPCLinuxAsmPrinter::emitFunctionBodyStart() {
// In the ELFv2 ABI, in functions that use the TOC register, we need to
// provide two entry points. The ABI guarantees that when calling the
// local entry point, r2 is set up by the caller to contain the TOC base
@ -1530,7 +1530,7 @@ void PPCLinuxAsmPrinter::EmitFunctionBodyStart() {
/// EmitFunctionBodyEnd - Print the traceback table before the .size
/// directive.
///
void PPCLinuxAsmPrinter::EmitFunctionBodyEnd() {
void PPCLinuxAsmPrinter::emitFunctionBodyEnd() {
// Only the 64-bit target requires a traceback table. For now,
// we only emit the word of zeroes that GDB requires to find
// the end of the function, and zeroes for the eight-byte
@ -1637,7 +1637,7 @@ void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
EmitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
}
void PPCAIXAsmPrinter::EmitFunctionDescriptor() {
void PPCAIXAsmPrinter::emitFunctionDescriptor() {
const DataLayout &DL = getDataLayout();
const unsigned PointerSize = DL.getPointerSizeInBits() == 64 ? 8 : 4;
@ -1661,7 +1661,7 @@ void PPCAIXAsmPrinter::EmitFunctionDescriptor() {
OutStreamer->SwitchSection(Current.first, Current.second);
}
void PPCAIXAsmPrinter::EmitEndOfAsmFile(Module &M) {
void PPCAIXAsmPrinter::emitEndOfAsmFile(Module &M) {
// If there are no functions in this module, we will never need to reference
// the TOC base.
if (M.empty())

4
lib/Target/Sparc/SparcAsmPrinter.cpp
View File

@ -52,7 +52,7 @@ namespace {
void printMemOperand(const MachineInstr *MI, int opNum, raw_ostream &OS,
const char *Modifier = nullptr);
void EmitFunctionBodyStart() override;
void emitFunctionBodyStart() override;
void EmitInstruction(const MachineInstr *MI) override;
static const char *getRegisterName(unsigned RegNo) {
@ -270,7 +270,7 @@ void SparcAsmPrinter::EmitInstruction(const MachineInstr *MI)
} while ((++I != E) && I->isInsideBundle()); // Delay slot check.
}
void SparcAsmPrinter::EmitFunctionBodyStart() {
void SparcAsmPrinter::emitFunctionBodyStart() {
if (!MF->getSubtarget<SparcSubtarget>().is64Bit())
return;

2
lib/Target/SystemZ/SystemZAsmPrinter.cpp
View File

@ -719,7 +719,7 @@ bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
return false;
}
void SystemZAsmPrinter::EmitEndOfAsmFile(Module &M) {
void SystemZAsmPrinter::emitEndOfAsmFile(Module &M) {
emitStackMaps(SM);
}

2
lib/Target/SystemZ/SystemZAsmPrinter.h
View File

@ -34,7 +34,7 @@ public:
StringRef getPassName() const override { return "SystemZ Assembly Printer"; }
void EmitInstruction(const MachineInstr *MI) override;
void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) override;
void EmitEndOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode, raw_ostream &OS) override;
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,

6
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp
View File

@ -85,7 +85,7 @@ WebAssemblyTargetStreamer *WebAssemblyAsmPrinter::getTargetStreamer() {
// WebAssemblyAsmPrinter Implementation.
//===----------------------------------------------------------------------===//
void WebAssemblyAsmPrinter::EmitEndOfAsmFile(Module &M) {
void WebAssemblyAsmPrinter::emitEndOfAsmFile(Module &M) {
for (auto &It : OutContext.getSymbols()) {
// Emit a .globaltype and .eventtype declaration.
auto Sym = cast<MCSymbolWasm>(It.getValue());
@ -286,7 +286,7 @@ void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
// Nothing to do; jump tables are incorporated into the instruction stream.
}
void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
void WebAssemblyAsmPrinter::emitFunctionBodyStart() {
const Function &F = MF->getFunction();
SmallVector<MVT, 1> ResultVTs;
SmallVector<MVT, 4> ParamVTs;
@ -312,7 +312,7 @@ void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
valTypesFromMVTs(MFI->getLocals(), Locals);
getTargetStreamer()->emitLocal(Locals);
AsmPrinter::EmitFunctionBodyStart();
AsmPrinter::emitFunctionBodyStart();
}
void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {

4
lib/Target/WebAssembly/WebAssemblyAsmPrinter.h
View File

@ -57,12 +57,12 @@ public:
// AsmPrinter Implementation.
//===------------------------------------------------------------------===//
void EmitEndOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
void EmitProducerInfo(Module &M);
void EmitTargetFeatures(Module &M);
void EmitJumpTableInfo() override;
void EmitConstantPool() override;
void EmitFunctionBodyStart() override;
void emitFunctionBodyStart() override;
void EmitInstruction(const MachineInstr *MI) override;
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode, raw_ostream &OS) override;

10
lib/Target/X86/X86AsmPrinter.cpp
View File

@ -76,7 +76,7 @@ bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
}
// Emit the rest of the function body.
EmitFunctionBody();
emitFunctionBody();
// Emit the XRay table for this function.
emitXRayTable();
@ -87,7 +87,7 @@ bool X86AsmPrinter::runOnMachineFunction(MachineFunction &MF) {
return false;
}
void X86AsmPrinter::EmitFunctionBodyStart() {
void X86AsmPrinter::emitFunctionBodyStart() {
if (EmitFPOData) {
if (auto *XTS =
static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
@ -97,7 +97,7 @@ void X86AsmPrinter::EmitFunctionBodyStart() {
}
}
void X86AsmPrinter::EmitFunctionBodyEnd() {
void X86AsmPrinter::emitFunctionBodyEnd() {
if (EmitFPOData) {
if (auto *XTS =
static_cast<X86TargetStreamer *>(OutStreamer->getTargetStreamer()))
@ -575,7 +575,7 @@ bool X86AsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
return false;
}
void X86AsmPrinter::EmitStartOfAsmFile(Module &M) {
void X86AsmPrinter::emitStartOfAsmFile(Module &M) {
const Triple &TT = TM.getTargetTriple();
if (TT.isOSBinFormatELF()) {
@ -698,7 +698,7 @@ static void emitNonLazyStubs(MachineModuleInfo *MMI, MCStreamer &OutStreamer) {
}
}
void X86AsmPrinter::EmitEndOfAsmFile(Module &M) {
void X86AsmPrinter::emitEndOfAsmFile(Module &M) {
const Triple &TT = TM.getTargetTriple();
if (TT.isOSBinFormatMachO()) {

12
lib/Target/X86/X86AsmPrinter.h
View File

@ -123,14 +123,14 @@ public:
const X86Subtarget &getSubtarget() const { return *Subtarget; }
void EmitStartOfAsmFile(Module &M) override;
void emitStartOfAsmFile(Module &M) override;
void EmitEndOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &M) override;
void EmitInstruction(const MachineInstr *MI) override;
void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override {
AsmPrinter::EmitBasicBlockEnd(MBB);
void emitBasicBlockEnd(const MachineBasicBlock &MBB) override {
AsmPrinter::emitBasicBlockEnd(MBB);
SMShadowTracker.emitShadowPadding(*OutStreamer, getSubtargetInfo());
}
@ -147,8 +147,8 @@ public:
}
bool runOnMachineFunction(MachineFunction &F) override;
void EmitFunctionBodyStart() override;
void EmitFunctionBodyEnd() override;
void emitFunctionBodyStart() override;
void emitFunctionBodyEnd() override;
};
} // end namespace llvm

4
lib/Target/X86/X86ISelDAGToDAG.cpp
View File

@ -196,7 +196,7 @@ namespace {
return true;
}
void EmitFunctionEntryCode() override;
void emitFunctionEntryCode() override;
bool IsProfitableToFold(SDValue N, SDNode *U, SDNode *Root) const override;
@ -1390,7 +1390,7 @@ void X86DAGToDAGISel::emitSpecialCodeForMain() {
}
}
void X86DAGToDAGISel::EmitFunctionEntryCode() {
void X86DAGToDAGISel::emitFunctionEntryCode() {
// If this is main, emit special code for main.
const Function &F = MF->getFunction();
if (F.hasExternalLinkage() && F.getName() == "main")

12
lib/Target/XCore/XCoreAsmPrinter.cpp
View File

@ -74,10 +74,10 @@ namespace {
void emitArrayBound(MCSymbol *Sym, const GlobalVariable *GV);
void EmitGlobalVariable(const GlobalVariable *GV) override;
void EmitFunctionEntryLabel() override;
void emitFunctionEntryLabel() override;
void EmitInstruction(const MachineInstr *MI) override;
void EmitFunctionBodyStart() override;
void EmitFunctionBodyEnd() override;
void emitFunctionBodyStart() override;
void emitFunctionBodyEnd() override;
};
} // end of anonymous namespace
@ -165,18 +165,18 @@ void XCoreAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
getTargetStreamer().emitCCBottomData(GVSym->getName());
}
void XCoreAsmPrinter::EmitFunctionBodyStart() {
void XCoreAsmPrinter::emitFunctionBodyStart() {
MCInstLowering.Initialize(&MF->getContext());
}
/// EmitFunctionBodyEnd - Targets can override this to emit stuff after
/// the last basic block in the function.
void XCoreAsmPrinter::EmitFunctionBodyEnd() {
void XCoreAsmPrinter::emitFunctionBodyEnd() {
// Emit function end directives
getTargetStreamer().emitCCBottomFunction(CurrentFnSym->getName());
}
void XCoreAsmPrinter::EmitFunctionEntryLabel() {
void XCoreAsmPrinter::emitFunctionEntryLabel() {
// Mark the start of the function
getTargetStreamer().emitCCTopFunction(CurrentFnSym->getName());
OutStreamer->EmitLabel(CurrentFnSym);