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
|
//===---- AMDILMCCodeEmitter.cpp - Convert AMDIL text to AMDIL binary ----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//==-----------------------------------------------------------------------===//
//
//===---------------------------------------------------------------------===//
#define DEBUG_TYPE "amdil-emitter"
#include "AMDIL.h"
#include "AMDILInstrInfo.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/MC/MCCodeEmitter.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInst.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
#if 0
namespace {
class AMDILMCCodeEmitter : public MCCodeEmitter {
AMDILMCCodeEmitter(const AMDILMCCodeEmitter &);// DO NOT IMPLEMENT
void operator=(const AMDILMCCodeEmitter &); // DO NOT IMPLEMENT
const TargetMachine &TM;
const TargetInstrInfo &TII;
MCContext &Ctx;
bool Is64BitMode;
public:
AMDILMCCodeEmitter(TargetMachine &tm, MCContext &ctx, bool is64Bit);
~AMDILMCCodeEmitter();
unsigned getNumFixupKinds() const;
const MCFixupKindInfo& getFixupKindInfo(MCFixupKind Kind) const;
static unsigned GetAMDILRegNum(const MCOperand &MO);
void EmitByte(unsigned char C, unsigned &CurByte, raw_ostream &OS) const;
void EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte,
raw_ostream &OS) const;
void EmitImmediate(const MCOperand &Disp, unsigned ImmSize,
MCFixupKind FixupKind, unsigned &CurByte, raw_ostream &os,
SmallVectorImpl<MCFixup> &Fixups, int ImmOffset = 0) const;
void EncodeInstruction(const MCInst &MI, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups) const;
}; // class AMDILMCCodeEmitter
}; // anonymous namespace
namespace llvm {
MCCodeEmitter *createAMDILMCCodeEmitter(const Target &,
TargetMachine &TM, MCContext &Ctx)
{
return new AMDILMCCodeEmitter(TM, Ctx, false);
}
}
AMDILMCCodeEmitter::AMDILMCCodeEmitter(TargetMachine &tm, MCContext &ctx
, bool is64Bit)
: TM(tm), TII(*TM.getInstrInfo()), Ctx(ctx)
{
Is64BitMode = is64Bit;
}
AMDILMCCodeEmitter::~AMDILMCCodeEmitter()
{
}
unsigned
AMDILMCCodeEmitter::getNumFixupKinds() const
{
return 0;
}
const MCFixupKindInfo &
AMDILMCCodeEmitter::getFixupKindInfo(MCFixupKind Kind) const
{
// const static MCFixupKindInfo Infos[] = {};
if (Kind < FirstTargetFixupKind) {
return MCCodeEmitter::getFixupKindInfo(Kind);
}
assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
"Invalid kind!");
return MCCodeEmitter::getFixupKindInfo(Kind);
// return Infos[Kind - FirstTargetFixupKind];
}
void
AMDILMCCodeEmitter::EmitByte(unsigned char C, unsigned &CurByte,
raw_ostream &OS) const
{
OS << (char) C;
++CurByte;
}
void
AMDILMCCodeEmitter::EmitConstant(uint64_t Val, unsigned Size, unsigned &CurByte,
raw_ostream &OS) const
{
// Output the constant in little endian byte order
for (unsigned i = 0; i != Size; ++i) {
EmitByte(Val & 255, CurByte, OS);
Val >>= 8;
}
}
void
AMDILMCCodeEmitter::EmitImmediate(const MCOperand &DispOp, unsigned ImmSize,
MCFixupKind FixupKind, unsigned &CurByte, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups, int ImmOffset) const
{
// If this is a simple integer displacement that doesn't require a relocation
// emit it now.
if (DispOp.isImm()) {
EmitConstant(DispOp.getImm() + ImmOffset, ImmSize, CurByte, OS);
}
// If we have an immoffset, add it to the expression
const MCExpr *Expr = DispOp.getExpr();
if (ImmOffset) {
Expr = MCBinaryExpr::CreateAdd(Expr,
MCConstantExpr::Create(ImmOffset, Ctx), Ctx);
}
// Emit a symbolic constant as a fixup and 4 zeros.
Fixups.push_back(MCFixup::Create(CurByte, Expr, FixupKind));
// TODO: Why the 4 zeros?
EmitConstant(0, ImmSize, CurByte, OS);
}
void
AMDILMCCodeEmitter::EncodeInstruction(const MCInst &MI, raw_ostream &OS,
SmallVectorImpl<MCFixup> &Fixups) const
{
#if 0
unsigned Opcode = MI.getOpcode();
const TargetInstrDesc &Desc = TII.get(Opcode);
unsigned TSFlags = Desc.TSFlags;
// Keep track of the current byte being emitted.
unsigned CurByte = 0;
unsigned NumOps = Desc.getNumOperands();
unsigned CurOp = 0;
unsigned char BaseOpcode = 0;
#ifndef NDEBUG
// FIXME: Verify.
if (// !Desc.isVariadic() &&
CurOp != NumOps) {
errs() << "Cannot encode all operands of: ";
MI.dump();
errs() << '\n';
abort();
}
#endif
#endif
}
#endif
|
