mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-17 03:30:28 +00:00
b576c94c15
Header files will be on the way. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9298 91177308-0d34-0410-b5e6-96231b3b80d8
298 lines
11 KiB
C++
298 lines
11 KiB
C++
//===-- InstructionWriter.cpp - Functions for writing instructions --------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the routines for encoding instruction opcodes to a
|
|
// bytecode stream.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "WriterInternals.h"
|
|
#include "llvm/Module.h"
|
|
#include "llvm/DerivedTypes.h"
|
|
#include "llvm/Instructions.h"
|
|
#include "Support/Statistic.h"
|
|
#include <algorithm>
|
|
|
|
static Statistic<>
|
|
NumInstrs("bytecodewriter", "Number of instructions");
|
|
|
|
typedef unsigned char uchar;
|
|
|
|
// outputInstructionFormat0 - Output those wierd instructions that have a large
|
|
// number of operands or have large operands themselves...
|
|
//
|
|
// Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
|
|
//
|
|
static void outputInstructionFormat0(const Instruction *I, unsigned Opcode,
|
|
const SlotCalculator &Table,
|
|
unsigned Type, std::deque<uchar> &Out) {
|
|
// Opcode must have top two bits clear...
|
|
output_vbr(Opcode << 2, Out); // Instruction Opcode ID
|
|
output_vbr(Type, Out); // Result type
|
|
|
|
unsigned NumArgs = I->getNumOperands();
|
|
output_vbr(NumArgs + (isa<CastInst>(I) || isa<VANextInst>(I) ||
|
|
isa<VAArgInst>(I)), Out);
|
|
|
|
for (unsigned i = 0; i < NumArgs; ++i) {
|
|
int Slot = Table.getSlot(I->getOperand(i));
|
|
assert(Slot >= 0 && "No slot number for value!?!?");
|
|
output_vbr((unsigned)Slot, Out);
|
|
}
|
|
|
|
if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
|
|
int Slot = Table.getSlot(I->getType());
|
|
assert(Slot != -1 && "Cast return type unknown?");
|
|
output_vbr((unsigned)Slot, Out);
|
|
} else if (const VANextInst *VAI = dyn_cast<VANextInst>(I)) {
|
|
int Slot = Table.getSlot(VAI->getArgType());
|
|
assert(Slot != -1 && "VarArg argument type unknown?");
|
|
output_vbr((unsigned)Slot, Out);
|
|
}
|
|
|
|
align32(Out); // We must maintain correct alignment!
|
|
}
|
|
|
|
|
|
// outputInstrVarArgsCall - Output the absurdly annoying varargs function calls.
|
|
// This are more annoying than most because the signature of the call does not
|
|
// tell us anything about the types of the arguments in the varargs portion.
|
|
// Because of this, we encode (as type 0) all of the argument types explicitly
|
|
// before the argument value. This really sucks, but you shouldn't be using
|
|
// varargs functions in your code! *death to printf*!
|
|
//
|
|
// Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
|
|
//
|
|
static void outputInstrVarArgsCall(const Instruction *I, unsigned Opcode,
|
|
const SlotCalculator &Table, unsigned Type,
|
|
std::deque<uchar> &Out) {
|
|
assert(isa<CallInst>(I) || isa<InvokeInst>(I));
|
|
// Opcode must have top two bits clear...
|
|
output_vbr(Opcode << 2, Out); // Instruction Opcode ID
|
|
output_vbr(Type, Out); // Result type (varargs type)
|
|
|
|
const PointerType *PTy = cast<PointerType>(I->getOperand(0)->getType());
|
|
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
|
unsigned NumParams = FTy->getNumParams();
|
|
|
|
unsigned NumFixedOperands;
|
|
if (isa<CallInst>(I)) {
|
|
// Output an operand for the callee and each fixed argument, then two for
|
|
// each variable argument.
|
|
NumFixedOperands = 1+NumParams;
|
|
} else {
|
|
assert(isa<InvokeInst>(I) && "Not call or invoke??");
|
|
// Output an operand for the callee and destinations, then two for each
|
|
// variable argument.
|
|
NumFixedOperands = 3+NumParams;
|
|
}
|
|
output_vbr(2 * I->getNumOperands()-NumFixedOperands, Out);
|
|
|
|
// The type for the function has already been emitted in the type field of the
|
|
// instruction. Just emit the slot # now.
|
|
for (unsigned i = 0; i != NumFixedOperands; ++i) {
|
|
int Slot = Table.getSlot(I->getOperand(i));
|
|
assert(Slot >= 0 && "No slot number for value!?!?");
|
|
output_vbr((unsigned)Slot, Out);
|
|
}
|
|
|
|
for (unsigned i = NumFixedOperands, e = I->getNumOperands(); i != e; ++i) {
|
|
// Output Arg Type ID
|
|
int Slot = Table.getSlot(I->getOperand(i)->getType());
|
|
assert(Slot >= 0 && "No slot number for value!?!?");
|
|
output_vbr((unsigned)Slot, Out);
|
|
|
|
// Output arg ID itself
|
|
Slot = Table.getSlot(I->getOperand(i));
|
|
assert(Slot >= 0 && "No slot number for value!?!?");
|
|
output_vbr((unsigned)Slot, Out);
|
|
}
|
|
align32(Out); // We must maintain correct alignment!
|
|
}
|
|
|
|
|
|
// outputInstructionFormat1 - Output one operand instructions, knowing that no
|
|
// operand index is >= 2^12.
|
|
//
|
|
static void outputInstructionFormat1(const Instruction *I, unsigned Opcode,
|
|
const SlotCalculator &Table, int *Slots,
|
|
unsigned Type, std::deque<uchar> &Out) {
|
|
// bits Instruction format:
|
|
// --------------------------
|
|
// 01-00: Opcode type, fixed to 1.
|
|
// 07-02: Opcode
|
|
// 19-08: Resulting type plane
|
|
// 31-20: Operand #1 (if set to (2^12-1), then zero operands)
|
|
//
|
|
unsigned Bits = 1 | (Opcode << 2) | (Type << 8) | (Slots[0] << 20);
|
|
// cerr << "1 " << IType << " " << Type << " " << Slots[0] << endl;
|
|
output(Bits, Out);
|
|
}
|
|
|
|
|
|
// outputInstructionFormat2 - Output two operand instructions, knowing that no
|
|
// operand index is >= 2^8.
|
|
//
|
|
static void outputInstructionFormat2(const Instruction *I, unsigned Opcode,
|
|
const SlotCalculator &Table, int *Slots,
|
|
unsigned Type, std::deque<uchar> &Out) {
|
|
// bits Instruction format:
|
|
// --------------------------
|
|
// 01-00: Opcode type, fixed to 2.
|
|
// 07-02: Opcode
|
|
// 15-08: Resulting type plane
|
|
// 23-16: Operand #1
|
|
// 31-24: Operand #2
|
|
//
|
|
unsigned Bits = 2 | (Opcode << 2) | (Type << 8) |
|
|
(Slots[0] << 16) | (Slots[1] << 24);
|
|
// cerr << "2 " << IType << " " << Type << " " << Slots[0] << " "
|
|
// << Slots[1] << endl;
|
|
output(Bits, Out);
|
|
}
|
|
|
|
|
|
// outputInstructionFormat3 - Output three operand instructions, knowing that no
|
|
// operand index is >= 2^6.
|
|
//
|
|
static void outputInstructionFormat3(const Instruction *I, unsigned Opcode,
|
|
const SlotCalculator &Table, int *Slots,
|
|
unsigned Type, std::deque<uchar> &Out) {
|
|
// bits Instruction format:
|
|
// --------------------------
|
|
// 01-00: Opcode type, fixed to 3.
|
|
// 07-02: Opcode
|
|
// 13-08: Resulting type plane
|
|
// 19-14: Operand #1
|
|
// 25-20: Operand #2
|
|
// 31-26: Operand #3
|
|
//
|
|
unsigned Bits = 3 | (Opcode << 2) | (Type << 8) |
|
|
(Slots[0] << 14) | (Slots[1] << 20) | (Slots[2] << 26);
|
|
//cerr << "3 " << IType << " " << Type << " " << Slots[0] << " "
|
|
// << Slots[1] << " " << Slots[2] << endl;
|
|
output(Bits, Out);
|
|
}
|
|
|
|
void BytecodeWriter::processInstruction(const Instruction &I) {
|
|
assert(I.getOpcode() < 62 && "Opcode too big???");
|
|
unsigned Opcode = I.getOpcode();
|
|
|
|
// Encode 'volatile load' as 62 and 'volatile store' as 63.
|
|
if (isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile())
|
|
Opcode = 62;
|
|
if (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())
|
|
Opcode = 63;
|
|
|
|
unsigned NumOperands = I.getNumOperands();
|
|
int MaxOpSlot = 0;
|
|
int Slots[3]; Slots[0] = (1 << 12)-1; // Marker to signify 0 operands
|
|
|
|
for (unsigned i = 0; i < NumOperands; ++i) {
|
|
const Value *Def = I.getOperand(i);
|
|
int slot = Table.getSlot(Def);
|
|
assert(slot != -1 && "Broken bytecode!");
|
|
if (slot > MaxOpSlot) MaxOpSlot = slot;
|
|
if (i < 3) Slots[i] = slot;
|
|
}
|
|
|
|
// Figure out which type to encode with the instruction. Typically we want
|
|
// the type of the first parameter, as opposed to the type of the instruction
|
|
// (for example, with setcc, we always know it returns bool, but the type of
|
|
// the first param is actually interesting). But if we have no arguments
|
|
// we take the type of the instruction itself.
|
|
//
|
|
const Type *Ty;
|
|
switch (I.getOpcode()) {
|
|
case Instruction::Malloc:
|
|
case Instruction::Alloca:
|
|
Ty = I.getType(); // Malloc & Alloca ALWAYS want to encode the return type
|
|
break;
|
|
case Instruction::Store:
|
|
Ty = I.getOperand(1)->getType(); // Encode the pointer type...
|
|
assert(isa<PointerType>(Ty) && "Store to nonpointer type!?!?");
|
|
break;
|
|
default: // Otherwise use the default behavior...
|
|
Ty = NumOperands ? I.getOperand(0)->getType() : I.getType();
|
|
break;
|
|
}
|
|
|
|
unsigned Type;
|
|
int Slot = Table.getSlot(Ty);
|
|
assert(Slot != -1 && "Type not available!!?!");
|
|
Type = (unsigned)Slot;
|
|
|
|
// Make sure that we take the type number into consideration. We don't want
|
|
// to overflow the field size for the instruction format we select.
|
|
//
|
|
if (Slot > MaxOpSlot) MaxOpSlot = Slot;
|
|
|
|
// Handle the special case for cast...
|
|
if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
|
|
// Cast has to encode the destination type as the second argument in the
|
|
// packet, or else we won't know what type to cast to!
|
|
Slots[1] = Table.getSlot(I.getType());
|
|
assert(Slots[1] != -1 && "Cast return type unknown?");
|
|
if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
|
|
NumOperands++;
|
|
} else if (const VANextInst *VANI = dyn_cast<VANextInst>(&I)) {
|
|
Slots[1] = Table.getSlot(VANI->getArgType());
|
|
assert(Slots[1] != -1 && "va_next return type unknown?");
|
|
if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
|
|
NumOperands++;
|
|
} else if (const CallInst *CI = dyn_cast<CallInst>(&I)){// Handle VarArg calls
|
|
const PointerType *Ty = cast<PointerType>(CI->getCalledValue()->getType());
|
|
if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
|
|
outputInstrVarArgsCall(CI, Opcode, Table, Type, Out);
|
|
return;
|
|
}
|
|
} else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {// ... & Invokes
|
|
const PointerType *Ty = cast<PointerType>(II->getCalledValue()->getType());
|
|
if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
|
|
outputInstrVarArgsCall(II, Opcode, Table, Type, Out);
|
|
return;
|
|
}
|
|
}
|
|
|
|
++NumInstrs;
|
|
|
|
// Decide which instruction encoding to use. This is determined primarily by
|
|
// the number of operands, and secondarily by whether or not the max operand
|
|
// will fit into the instruction encoding. More operands == fewer bits per
|
|
// operand.
|
|
//
|
|
switch (NumOperands) {
|
|
case 0:
|
|
case 1:
|
|
if (MaxOpSlot < (1 << 12)-1) { // -1 because we use 4095 to indicate 0 ops
|
|
outputInstructionFormat1(&I, Opcode, Table, Slots, Type, Out);
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
if (MaxOpSlot < (1 << 8)) {
|
|
outputInstructionFormat2(&I, Opcode, Table, Slots, Type, Out);
|
|
return;
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
if (MaxOpSlot < (1 << 6)) {
|
|
outputInstructionFormat3(&I, Opcode, Table, Slots, Type, Out);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// If we weren't handled before here, we either have a large number of
|
|
// operands or a large operand index that we are referring to.
|
|
outputInstructionFormat0(&I, Opcode, Table, Type, Out);
|
|
}
|