LLVM  9.0.0svn
MipsAsmPrinter.h
Go to the documentation of this file.
1 //===- MipsAsmPrinter.h - Mips LLVM Assembly Printer -----------*- 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 // Mips Assembly printer class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_LIB_TARGET_MIPS_MIPSASMPRINTER_H
14 #define LLVM_LIB_TARGET_MIPS_MIPSASMPRINTER_H
15 
16 #include "Mips16HardFloatInfo.h"
17 #include "MipsMCInstLower.h"
18 #include "MipsSubtarget.h"
20 #include "llvm/MC/MCStreamer.h"
21 #include "llvm/Support/Compiler.h"
22 #include <algorithm>
23 #include <map>
24 #include <memory>
25 
26 namespace llvm {
27 
28 class MCOperand;
29 class MCSubtargetInfo;
30 class MCSymbol;
31 class MachineBasicBlock;
32 class MachineConstantPool;
33 class MachineFunction;
34 class MachineInstr;
35 class MachineOperand;
36 class MipsFunctionInfo;
37 class MipsTargetStreamer;
38 class Module;
39 class raw_ostream;
40 class TargetMachine;
41 
43  MipsTargetStreamer &getTargetStreamer() const;
44 
45  void EmitInstrWithMacroNoAT(const MachineInstr *MI);
46 
47  //===------------------------------------------------------------------===//
48  // XRay implementation
49  //===------------------------------------------------------------------===//
50 
51 public:
52  // XRay-specific lowering for Mips.
53  void LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI);
54  void LowerPATCHABLE_FUNCTION_EXIT(const MachineInstr &MI);
55  void LowerPATCHABLE_TAIL_CALL(const MachineInstr &MI);
56 
57 private:
58  /// MCP - Keep a pointer to constantpool entries of the current
59  /// MachineFunction.
60  const MachineConstantPool *MCP = nullptr;
61 
62  /// InConstantPool - Maintain state when emitting a sequence of constant
63  /// pool entries so we can properly mark them as data regions.
64  bool InConstantPool = false;
65 
66  std::map<const char *, const Mips16HardFloatInfo::FuncSignature *>
67  StubsNeeded;
68 
69  void EmitSled(const MachineInstr &MI, SledKind Kind);
70 
71  // tblgen'erated function.
72  bool emitPseudoExpansionLowering(MCStreamer &OutStreamer,
73  const MachineInstr *MI);
74 
75  // Emit PseudoReturn, PseudoReturn64, PseudoIndirectBranch,
76  // and PseudoIndirectBranch64 as a JR, JR_MM, JALR, or JALR64 as appropriate
77  // for the target.
78  void emitPseudoIndirectBranch(MCStreamer &OutStreamer,
79  const MachineInstr *MI);
80 
81  // lowerOperand - Convert a MachineOperand into the equivalent MCOperand.
82  bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp);
83 
84  void emitInlineAsmStart() const override;
85 
86  void emitInlineAsmEnd(const MCSubtargetInfo &StartInfo,
87  const MCSubtargetInfo *EndInfo) const override;
88 
89  void EmitJal(const MCSubtargetInfo &STI, MCSymbol *Symbol);
90 
91  void EmitInstrReg(const MCSubtargetInfo &STI, unsigned Opcode, unsigned Reg);
92 
93  void EmitInstrRegReg(const MCSubtargetInfo &STI, unsigned Opcode,
94  unsigned Reg1, unsigned Reg2);
95 
96  void EmitInstrRegRegReg(const MCSubtargetInfo &STI, unsigned Opcode,
97  unsigned Reg1, unsigned Reg2, unsigned Reg3);
98 
99  void EmitMovFPIntPair(const MCSubtargetInfo &STI, unsigned MovOpc,
100  unsigned Reg1, unsigned Reg2, unsigned FPReg1,
101  unsigned FPReg2, bool LE);
102 
103  void EmitSwapFPIntParams(const MCSubtargetInfo &STI,
105  bool ToFP);
106 
107  void EmitSwapFPIntRetval(const MCSubtargetInfo &STI,
109 
110  void EmitFPCallStub(const char *, const Mips16HardFloatInfo::FuncSignature *);
111 
112  void NaClAlignIndirectJumpTargets(MachineFunction &MF);
113 
114  bool isLongBranchPseudo(int Opcode) const;
115 
116 public:
120 
122  std::unique_ptr<MCStreamer> Streamer)
123  : AsmPrinter(TM, std::move(Streamer)), MCInstLowering(*this) {}
124 
125  StringRef getPassName() const override { return "Mips Assembly Printer"; }
126 
127  bool runOnMachineFunction(MachineFunction &MF) override;
128 
129  void EmitConstantPool() override {
130  bool UsingConstantPools =
131  (Subtarget->inMips16Mode() && Subtarget->useConstantIslands());
132  if (!UsingConstantPools)
134  // we emit constant pools customly!
135  }
136 
137  void EmitInstruction(const MachineInstr *MI) override;
138  void printSavedRegsBitmask();
139  void emitFrameDirective();
140  const char *getCurrentABIString() const;
141  void EmitFunctionEntryLabel() override;
142  void EmitFunctionBodyStart() override;
143  void EmitFunctionBodyEnd() override;
144  void EmitBasicBlockEnd(const MachineBasicBlock &MBB) override;
145  bool isBlockOnlyReachableByFallthrough(
146  const MachineBasicBlock* MBB) const override;
147  bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
148  const char *ExtraCode, raw_ostream &O) override;
149  bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNum,
150  const char *ExtraCode, raw_ostream &O) override;
151  void printOperand(const MachineInstr *MI, int opNum, raw_ostream &O);
152  void printMemOperand(const MachineInstr *MI, int opNum, raw_ostream &O);
153  void printMemOperandEA(const MachineInstr *MI, int opNum, raw_ostream &O);
154  void printFCCOperand(const MachineInstr *MI, int opNum, raw_ostream &O,
155  const char *Modifier = nullptr);
156  void printRegisterList(const MachineInstr *MI, int opNum, raw_ostream &O);
157  void EmitStartOfAsmFile(Module &M) override;
158  void EmitEndOfAsmFile(Module &M) override;
159  void PrintDebugValueComment(const MachineInstr *MI, raw_ostream &OS);
160  void EmitDebugValue(const MCExpr *Value, unsigned Size) const override;
161 };
162 
163 } // end namespace llvm
164 
165 #endif // LLVM_LIB_TARGET_MIPS_MIPSASMPRINTER_H
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
bool inMips16Mode() const
unsigned Reg
virtual void EmitConstantPool()
Print to the current output stream assembly representations of the constants in the constant pool MCP...
Definition: BitVector.h:937
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
MipsMCInstLower - This class is used to lower an MachineInstr into an MCInst.
StringRef getPassName() const override
getPassName - Return a nice clean name for a pass.
void EmitConstantPool() override
Print to the current output stream assembly representations of the constants in the constant pool MCP...
Streaming machine code generation interface.
Definition: MCStreamer.h:188
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
#define LLVM_LIBRARY_VISIBILITY
LLVM_LIBRARY_VISIBILITY - If a class marked with this attribute is linked into a shared library...
Definition: Compiler.h:107
MipsMCInstLower MCInstLowering
MipsAsmPrinter(TargetMachine &TM, std::unique_ptr< MCStreamer > Streamer)
static bool useConstantIslands()
static void printMemOperand(raw_ostream &OS, const MachineMemOperand &MMO, const MachineFunction *MF, const Module *M, const MachineFrameInfo *MFI, const TargetInstrInfo *TII, LLVMContext &Ctx)
MachineOperand class - Representation of each machine instruction operand.
Representation of each machine instruction.
Definition: MachineInstr.h:63
static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)
const MipsSubtarget * Subtarget
Generic base class for all target subtargets.
MipsFunctionInfo - This class is derived from MachineFunction private Mips target-specific informatio...
uint32_t Size
Definition: Profile.cpp:46
LLVM Value Representation.
Definition: Value.h:72
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
const MipsFunctionInfo * MipsFI
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