LLVM  10.0.0svn
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 
16 namespace llvm {
17 
18 class ARMFunctionInfo;
19 class MCOperand;
20 class MachineConstantPool;
21 class MachineOperand;
22 class MCSymbol;
23 
24 namespace 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.
51  SmallVector<std::pair<unsigned, MCSymbol*>, 4> ThumbIndirectPads;
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 
68 public:
69  explicit ARMAsmPrinter(TargetMachine &TM,
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  //===------------------------------------------------------------------===//
111 public:
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 
117 private:
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 
132 public:
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() ||
141  return isThumb ? ARM::DW_ISA_ARM_thumb : ARM::DW_ISA_ARM_arm;
142  }
143 
144 private:
146  MCSymbol *GetARMJTIPICJumpTableLabel(unsigned uid) const;
147 
148  MCSymbol *GetARMGVSymbol(const GlobalValue *GV, unsigned char TargetFlags);
149 
150 public:
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
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
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.
F(f)
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
Definition: ARMAsmPrinter.h:72
static bool isThumb(const MCSubtargetInfo &STI)
SubArchType getSubArch() const
getSubArch - get the parsed subarchitecture type for this triple.
Definition: Triple.h:299
Streaming machine code generation interface.
Definition: MCStreamer.h:189
This is an important base class in LLVM.
Definition: Constant.h:41
static MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol, HexagonAsmPrinter &Printer, bool MustExtend)
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
const Triple & getTargetTriple() const
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library...
Definition: Compiler.h:115
bool isOSBinFormatMachO() const
Tests whether the environment is MachO.
Definition: Triple.h:633
Abstract base class for all machine specific constantpool value subclasses.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:417
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
Representation of each machine instruction.
Definition: MachineInstr.h:64
static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)
bool isThumb() const
Tests whether the target is Thumb (little and big endian).
Definition: Triple.h:694
ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific in...
Generic base class for all target subtargets.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:34