LLVM 19.0.0git
M68kAsmPrinter.cpp
Go to the documentation of this file.
1//===-- M68kAsmPrinter.cpp - M68k 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/// \file
10/// This file contains a printer that converts from our internal representation
11/// of machine-dependent LLVM code to GAS-format M68k assembly language.
12///
13//===----------------------------------------------------------------------===//
14
15// TODO Conform to Motorola ASM syntax
16
17#include "M68kAsmPrinter.h"
18
19#include "M68k.h"
20#include "M68kMachineFunction.h"
23
25
26using namespace llvm;
27
28#define DEBUG_TYPE "m68k-asm-printer"
29
32 MCInstLowering = std::make_unique<M68kMCInstLower>(MF, *this);
34 return true;
35}
36
37void M68kAsmPrinter::printOperand(const MachineInstr *MI, int OpNum,
38 raw_ostream &OS) {
39 const MachineOperand &MO = MI->getOperand(OpNum);
40 switch (MO.getType()) {
43 break;
45 OS << '#' << MO.getImm();
46 break;
48 MO.getMBB()->getSymbol()->print(OS, MAI);
49 break;
52 break;
55 break;
57 const DataLayout &DL = getDataLayout();
58 OS << DL.getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
59 << MO.getIndex();
60 break;
61 }
62 default:
63 llvm_unreachable("not implemented");
64 }
65}
66
68 const char *ExtraCode, raw_ostream &OS) {
69 // Print the operand if there is no operand modifier.
70 if (!ExtraCode || !ExtraCode[0]) {
71 printOperand(MI, OpNo, OS);
72 return false;
73 }
74
75 // Fallback to the default implementation.
76 return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS);
77}
78
79void M68kAsmPrinter::printDisp(const MachineInstr *MI, unsigned opNum,
80 raw_ostream &O) {
81 // Print immediate displacement without the '#' predix
82 const MachineOperand &Op = MI->getOperand(opNum);
83 if (Op.isImm()) {
84 O << Op.getImm();
85 return;
86 }
87 // Displacement is relocatable, so we're pretty permissive about what
88 // can be put here.
89 printOperand(MI, opNum, O);
90}
91
92void M68kAsmPrinter::printAbsMem(const MachineInstr *MI, unsigned OpNum,
93 raw_ostream &O) {
94 const MachineOperand &MO = MI->getOperand(OpNum);
95 if (MO.isImm())
96 O << format("$%0" PRIx64, (uint64_t)MO.getImm());
97 else
98 PrintAsmMemoryOperand(MI, OpNum, nullptr, O);
99}
100
102 unsigned OpNo, const char *ExtraCode,
103 raw_ostream &OS) {
104 const MachineOperand &MO = MI->getOperand(OpNo);
105 switch (MO.getType()) {
107 // Immediate value that goes here is the addressing mode kind we set
108 // in M68kDAGToDAGISel::SelectInlineAsmMemoryOperand.
109 using namespace M68k;
110 // Skip the addressing mode kind operand.
111 ++OpNo;
112 // Decode MemAddrModeKind.
113 switch (static_cast<MemAddrModeKind>(MO.getImm())) {
114 case MemAddrModeKind::j:
115 printARIMem(MI, OpNo, OS);
116 break;
117 case MemAddrModeKind::o:
118 printARIPIMem(MI, OpNo, OS);
119 break;
120 case MemAddrModeKind::e:
121 printARIPDMem(MI, OpNo, OS);
122 break;
123 case MemAddrModeKind::p:
124 printARIDMem(MI, OpNo, OS);
125 break;
126 case MemAddrModeKind::f:
127 case MemAddrModeKind::F:
128 printARIIMem(MI, OpNo, OS);
129 break;
130 case MemAddrModeKind::k:
131 printPCIMem(MI, 0, OpNo, OS);
132 break;
133 case MemAddrModeKind::q:
134 printPCDMem(MI, 0, OpNo, OS);
135 break;
136 case MemAddrModeKind::b:
137 printAbsMem(MI, OpNo, OS);
138 break;
139 default:
140 llvm_unreachable("Unrecognized memory addressing mode");
141 }
142 return false;
145 return false;
148 return false;
150 // This is a special case where it is treated as a memory reference, with
151 // the register holding the address value. Thus, we print it as ARI here.
153 printARIMem(MI, OpNo, OS);
154 return false;
155 }
156 break;
157 default:
158 break;
159 }
160 return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
161}
162
164 M68k_MC::verifyInstructionPredicates(MI->getOpcode(),
165 getSubtargetInfo().getFeatureBits());
166
167 switch (MI->getOpcode()) {
168 default: {
169 if (MI->isPseudo()) {
170 LLVM_DEBUG(dbgs() << "Pseudo opcode(" << MI->getOpcode()
171 << ") found in EmitInstruction()\n");
172 llvm_unreachable("Cannot proceed");
173 }
174 break;
175 }
176 case M68k::TAILJMPj:
177 case M68k::TAILJMPq:
178 // Lower these as normal, but add some comments.
179 OutStreamer->AddComment("TAILCALL");
180 break;
181 }
182
183 MCInst TmpInst0;
184 MCInstLowering->Lower(MI, TmpInst0);
185 OutStreamer->emitInstruction(TmpInst0, getSubtargetInfo());
186}
187
189
191
193 OutStreamer->emitSyntaxDirective();
194}
195
197
200}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
#define LLVM_DEBUG(X)
Definition: Debug.h:101
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
IRTranslator LLVM IR MI
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeM68kAsmPrinter()
This file contains M68k assembler printer declarations.
This file contains declarations for an M68k MCInst printer.
This file declares the M68k specific subclass of MachineFunctionInfo.
This file contains the entry points for global functions defined in the M68k target library,...
raw_pwrite_stream & OS
virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS)
Print the MachineOperand as a symbol.
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:90
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:102
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:394
bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
Definition: AsmPrinter.h:395
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:99
virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
MCSymbol * GetBlockAddressSymbol(const BlockAddress *BA) const
Return the MCSymbol used to satisfy BlockAddress uses of the specified basic block.
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:402
const MCSubtargetInfo & getSubtargetInfo() const
Return information about subtarget.
Definition: AsmPrinter.cpp:413
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
void emitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
virtual bool runOnMachineFunction(MachineFunction &MF) override
Emit the specified function out to the OutStreamer.
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
void emitInstruction(const MachineInstr *MI) override
Targets should implement this to emit instructions.
void emitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
void emitStartOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the start of their fi...
std::unique_ptr< M68kMCInstLower > MCInstLowering
void emitFunctionBodyEnd() override
Targets can override this to emit stuff after the last basic block in the function.
const M68kMachineFunctionInfo * MMFI
static const char * getRegisterName(MCRegister Reg)
void printARIDMem(const MachineInstr *MI, unsigned OpNum, raw_ostream &O)
void printPCDMem(const MachineInstr *MI, uint64_t Address, unsigned OpNum, raw_ostream &O)
void printPCIMem(const MachineInstr *MI, uint64_t Address, unsigned OpNum, raw_ostream &O)
void printARIPDMem(const MachineInstr *MI, unsigned OpNum, raw_ostream &O)
void printARIPIMem(const MachineInstr *MI, unsigned OpNum, raw_ostream &O)
void printARIIMem(const MachineInstr *MI, unsigned OpNum, raw_ostream &O)
void printARIMem(const MachineInstr *MI, unsigned OpNum, raw_ostream &O)
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:58
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
Representation of each machine instruction.
Definition: MachineInstr.h:68
MachineOperand class - Representation of each machine instruction operand.
int64_t getImm() const
MachineBasicBlock * getMBB() const
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
const BlockAddress * getBlockAddress() const
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Register getReg() const
getReg - Returns the register number.
@ MO_Immediate
Immediate operand.
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
@ MO_GlobalAddress
Address of a global value.
@ MO_BlockAddress
Address of a basic block.
@ MO_MachineBasicBlock
MachineBasicBlock reference.
@ MO_Register
Register operand.
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static bool isAddressRegister(unsigned RegNo)
Definition: M68kBaseInfo.h:252
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:125
Target & getTheM68kTarget()
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...