1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
//===-- M68kInstPrinter.cpp - Convert M68k MCInst to asm --------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains definitions for an M68k MCInst printer.
///
//===----------------------------------------------------------------------===//
// TODO Conform with all supported Motorola ASM syntax
// Motorola's assembly has several syntax variants, especially on
// addressing modes.
// For example, you can write pc indirect w/ displacement as
// `x(%pc)`, where `x` is the displacement imm, or `(x,%pc)`.
// Currently we're picking the variant that is different from
// GCC, albeit being recognizable by GNU AS.
// Not sure what is the impact now (e.g. some syntax might
// not be recognized by some old consoles' toolchains, in which
// case we can not use our integrated assembler), but either way,
// it will be great to support all of the variants in the future.
#include "M68kInstPrinter.h"
#include "M68kBaseInfo.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstrInfo.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
#define DEBUG_TYPE "asm-printer"
#define PRINT_ALIAS_INSTR
#include "M68kGenAsmWriter.inc"
void M68kInstPrinter::printRegName(raw_ostream &OS, MCRegister Reg) const {
OS << "%" << getRegisterName(Reg);
}
void M68kInstPrinter::printInst(const MCInst *MI, uint64_t Address,
StringRef Annot, const MCSubtargetInfo &STI,
raw_ostream &O) {
if (!printAliasInstr(MI, Address, O))
printInstruction(MI, Address, O);
printAnnotation(O, Annot);
}
void M68kInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
raw_ostream &O) {
const MCOperand &MO = MI->getOperand(OpNo);
if (MO.isReg()) {
printRegName(O, MO.getReg());
return;
}
if (MO.isImm()) {
printImmediate(MI, OpNo, O);
return;
}
assert(MO.isExpr() && "Unknown operand kind in printOperand");
MO.getExpr()->print(O, &MAI);
}
void M68kInstPrinter::printImmediate(const MCInst *MI, unsigned opNum,
raw_ostream &O) {
const MCOperand &MO = MI->getOperand(opNum);
if (MO.isImm())
O << '#' << MO.getImm();
else if (MO.isExpr()) {
O << '#';
MO.getExpr()->print(O, &MAI);
} else
llvm_unreachable("Unknown immediate kind");
}
void M68kInstPrinter::printMoveMask(const MCInst *MI, unsigned opNum,
raw_ostream &O) {
unsigned Mask = MI->getOperand(opNum).getImm();
assert((Mask & 0xFFFF) == Mask && "Mask is always 16 bits");
// A move mask is splitted into two parts:
// bits 0 ~ 7 correspond to D0 ~ D7 regs
// bits 8 ~ 15 correspond to A0 ~ A7 regs
//
// In the assembly syntax, we want to use a dash to replace
// a continuous range of registers. For example, if the bit
// mask is 0b101110, we want to print "D1-D3,D5" instead of
// "D1,D2,D3,D4,D5".
//
// However, we don't want a dash to cross between data registers
// and address registers (i.e. there shouldn't be a dash crossing
// bit 7 and 8) since that is not really intuitive. So we simply
// print the data register part (bit 0~7) and address register part
// separately.
uint8_t HalfMask;
unsigned Reg;
for (int s = 0; s < 16; s += 8) {
HalfMask = (Mask >> s) & 0xFF;
// Print separation comma only if
// both data & register parts have bit(s) set
if (s != 0 && (Mask & 0xFF) && HalfMask)
O << '/';
for (int i = 0; HalfMask; ++i) {
if ((HalfMask >> i) & 0b1) {
HalfMask ^= 0b1 << i;
Reg = M68kII::getMaskedSpillRegister(i + s);
printRegName(O, Reg);
int j = i;
while ((HalfMask >> (j + 1)) & 0b1)
HalfMask ^= 0b1 << ++j;
if (j != i) {
O << '-';
Reg = M68kII::getMaskedSpillRegister(j + s);
printRegName(O, Reg);
}
i = j;
if (HalfMask)
O << '/';
}
}
}
}
void M68kInstPrinter::printDisp(const MCInst *MI, unsigned opNum,
raw_ostream &O) {
const MCOperand &Op = MI->getOperand(opNum);
if (Op.isImm()) {
O << Op.getImm();
return;
}
assert(Op.isExpr() && "Unknown operand kind in printOperand");
Op.getExpr()->print(O, &MAI);
}
// NOTE forcing (W,L) size available since M68020 only
void M68kInstPrinter::printAbsMem(const MCInst *MI, unsigned opNum,
raw_ostream &O) {
const MCOperand &MO = MI->getOperand(opNum);
if (MO.isExpr()) {
MO.getExpr()->print(O, &MAI);
return;
}
assert(MO.isImm() && "absolute memory addressing needs an immediate");
O << format("$%0" PRIx64, (uint64_t)MO.getImm());
}
|
