LLVM 17.0.0git
ARMAsmPrinter.h
Go to the documentation of this file.
1//===-- ARMAsmPrinter.h - ARM implementation of AsmPrinter ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_LIB_TARGET_ARM_ARMASMPRINTER_H
10#define LLVM_LIB_TARGET_ARM_ARMASMPRINTER_H
11
12#include "ARMSubtarget.h"
15
16namespace llvm {
17
18class ARMFunctionInfo;
19class MCOperand;
20class MachineConstantPool;
21class MachineOperand;
22class MCSymbol;
23
24namespace ARM {
25 enum DW_ISA {
28 };
29}
30
32
33 /// Subtarget - Keep a pointer to the ARMSubtarget around so that we can
34 /// make the right decision when printing asm code for different targets.
35 const ARMSubtarget *Subtarget;
36
37 /// AFI - Keep a pointer to ARMFunctionInfo for the current
38 /// MachineFunction.
39 ARMFunctionInfo *AFI;
40
41 /// MCP - Keep a pointer to constantpool entries of the current
42 /// MachineFunction.
43 const MachineConstantPool *MCP;
44
45 /// InConstantPool - Maintain state when emitting a sequence of constant
46 /// pool entries so we can properly mark them as data regions.
47 bool InConstantPool;
48
49 /// ThumbIndirectPads - These maintain a per-function list of jump pad
50 /// labels used for ARMv4t thumb code to make register indirect calls.
52
53 /// OptimizationGoals - Maintain a combined optimization goal for all
54 /// functions in a module: one of Tag_ABI_optimization_goals values,
55 /// -1 if uninitialized, 0 if conflicting goals
56 int OptimizationGoals;
57
58 /// List of globals that have had their storage promoted to a constant
59 /// pool. This lives between calls to runOnMachineFunction and collects
60 /// data from every MachineFunction. It is used during doFinalization
61 /// when all non-function globals are emitted.
63 /// Set of globals in PromotedGlobals that we've emitted labels for.
64 /// We need to emit labels even for promoted globals so that DWARF
65 /// debug info can link properly.
66 SmallPtrSet<const GlobalVariable*,2> EmittedPromotedGlobalLabels;
67
68public:
70 std::unique_ptr<MCStreamer> Streamer);
71
72 StringRef getPassName() const override {
73 return "ARM Assembly Printer";
74 }
75
76 void printOperand(const MachineInstr *MI, int OpNum, raw_ostream &O);
77
78 void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &O) override;
79 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNum,
80 const char *ExtraCode, raw_ostream &O) override;
81 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
82 const char *ExtraCode, raw_ostream &O) override;
83
84 void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
85 const MCSubtargetInfo *EndInfo) const override;
86
87 void emitJumpTableAddrs(const MachineInstr *MI);
88 void emitJumpTableInsts(const MachineInstr *MI);
89 void emitJumpTableTBInst(const MachineInstr *MI, unsigned OffsetWidth);
90 void emitInstruction(const MachineInstr *MI) override;
91 bool runOnMachineFunction(MachineFunction &F) override;
92
93 void emitConstantPool() override {
94 // we emit constant pools customly!
95 }
96 void emitFunctionBodyEnd() override;
97 void emitFunctionEntryLabel() override;
98 void emitStartOfAsmFile(Module &M) override;
99 void emitEndOfAsmFile(Module &M) override;
100 void emitXXStructor(const DataLayout &DL, const Constant *CV) override;
101 void emitGlobalVariable(const GlobalVariable *GV) override;
102
103 MCSymbol *GetCPISymbol(unsigned CPID) const override;
104
105 // lowerOperand - Convert a MachineOperand into the equivalent MCOperand.
106 bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp);
107
108 //===------------------------------------------------------------------===//
109 // XRay implementation
110 //===------------------------------------------------------------------===//
111public:
112 // XRay-specific lowering for ARM.
113 void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI);
114 void LowerPATCHABLE_FUNCTION_EXIT(const MachineInstr &MI);
115 void LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI);
116
117private:
118 void EmitSled(const MachineInstr &MI, SledKind Kind);
119
120 // Helpers for emitStartOfAsmFile() and emitEndOfAsmFile()
121 void emitAttributes();
122
123 // Generic helper used to emit e.g. ARMv5 mul pseudos
124 void EmitPatchedInstruction(const MachineInstr *MI, unsigned TargetOpc);
125
126 void EmitUnwindingInstruction(const MachineInstr *MI);
127
128 // emitPseudoExpansionLowering - tblgen'erated.
129 bool emitPseudoExpansionLowering(MCStreamer &OutStreamer,
130 const MachineInstr *MI);
131
132public:
133 unsigned getISAEncoding() override {
134 // ARM/Darwin adds ISA to the DWARF info for each function.
135 const Triple &TT = TM.getTargetTriple();
136 if (!TT.isOSBinFormatMachO())
137 return 0;
138 bool isThumb = TT.isThumb() ||
139 TT.getSubArch() == Triple::ARMSubArch_v7m ||
140 TT.getSubArch() == Triple::ARMSubArch_v6m;
142 }
143
144private:
145 MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol);
146 MCSymbol *GetARMJTIPICJumpTableLabel(unsigned uid) const;
147
148 MCSymbol *GetARMGVSymbol(const GlobalValue *GV, unsigned char TargetFlags);
149
150public:
151 /// EmitMachineConstantPoolValue - Print a machine constantpool value to
152 /// the .s file.
153 void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) override;
154};
155} // end namespace llvm
156
157#endif
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool isThumb(const MCSubtargetInfo &STI)
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library,...
Definition: Compiler.h:126
static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol, HexagonAsmPrinter &Printer, bool MustExtend)
IRTranslator LLVM IR MI
#define F(x, y, z)
Definition: MD5.cpp:55
const char LLVMTargetMachineRef TM
static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)
void emitConstantPool() override
Print to the current output stream assembly representations of the constants in the constant pool MCP...
Definition: ARMAsmPrinter.h:93
unsigned getISAEncoding() override
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: ARMAsmPrinter.h:72
ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific in...
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:84
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:36
Streaming machine code generation interface.
Definition: MCStreamer.h:212
Generic base class for all target subtargets.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
Abstract base class for all machine specific constantpool value subclasses.
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
Representation of each machine instruction.
Definition: MachineInstr.h:68
MachineOperand class - Representation of each machine instruction operand.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:450
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:78
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
@ ARMSubArch_v7m
Definition: Triple.h:135
@ ARMSubArch_v6m
Definition: Triple.h:140
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
@ DW_ISA_ARM_thumb
Definition: ARMAsmPrinter.h:26
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18