2002-10-25 22:55:53 +00:00
|
|
|
//===-- InstSelectSimple.cpp - A simple instruction selector for x86 ------===//
|
|
|
|
//
|
|
|
|
// This file defines a simple peephole instruction selector for the x86 platform
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "X86.h"
|
2002-10-29 21:05:24 +00:00
|
|
|
#include "X86InstrInfo.h"
|
2002-11-17 21:11:55 +00:00
|
|
|
#include "X86InstrBuilder.h"
|
2002-10-25 22:55:53 +00:00
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/iTerminators.h"
|
2002-11-07 17:59:21 +00:00
|
|
|
#include "llvm/iOperators.h"
|
2002-10-31 23:03:59 +00:00
|
|
|
#include "llvm/iOther.h"
|
2002-11-02 19:45:49 +00:00
|
|
|
#include "llvm/iPHINode.h"
|
2002-11-17 21:11:55 +00:00
|
|
|
#include "llvm/iMemory.h"
|
2002-10-25 22:55:53 +00:00
|
|
|
#include "llvm/Type.h"
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2002-10-27 21:16:59 +00:00
|
|
|
#include "llvm/Constants.h"
|
2002-10-29 22:37:54 +00:00
|
|
|
#include "llvm/Pass.h"
|
2002-10-29 17:43:55 +00:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
2002-11-20 00:58:23 +00:00
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2002-10-25 22:55:53 +00:00
|
|
|
#include "llvm/Support/InstVisitor.h"
|
2002-11-20 00:58:23 +00:00
|
|
|
#include "llvm/Target/MRegisterInfo.h"
|
|
|
|
#include <map>
|
2002-10-25 22:55:53 +00:00
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
using namespace MOTy; // Get Use, Def, UseAndDef
|
|
|
|
|
2002-10-25 22:55:53 +00:00
|
|
|
namespace {
|
2002-10-29 22:37:54 +00:00
|
|
|
struct ISel : public FunctionPass, InstVisitor<ISel> {
|
|
|
|
TargetMachine &TM;
|
2002-10-29 17:43:55 +00:00
|
|
|
MachineFunction *F; // The function we are compiling into
|
|
|
|
MachineBasicBlock *BB; // The current MBB we are compiling
|
2002-10-25 22:55:53 +00:00
|
|
|
|
|
|
|
unsigned CurReg;
|
|
|
|
std::map<Value*, unsigned> RegMap; // Mapping between Val's and SSA Regs
|
|
|
|
|
2002-10-29 22:37:54 +00:00
|
|
|
ISel(TargetMachine &tm)
|
|
|
|
: TM(tm), F(0), BB(0), CurReg(MRegisterInfo::FirstVirtualRegister) {}
|
2002-10-25 22:55:53 +00:00
|
|
|
|
|
|
|
/// runOnFunction - Top level implementation of instruction selection for
|
|
|
|
/// the entire function.
|
|
|
|
///
|
2002-10-29 22:37:54 +00:00
|
|
|
bool runOnFunction(Function &Fn) {
|
2002-10-29 23:40:58 +00:00
|
|
|
F = &MachineFunction::construct(&Fn, TM);
|
2002-10-29 22:37:54 +00:00
|
|
|
visit(Fn);
|
2002-10-25 22:55:53 +00:00
|
|
|
RegMap.clear();
|
2002-11-21 17:26:58 +00:00
|
|
|
CurReg = MRegisterInfo::FirstVirtualRegister;
|
2002-10-29 22:37:54 +00:00
|
|
|
F = 0;
|
2002-10-25 22:55:53 +00:00
|
|
|
return false; // We never modify the LLVM itself.
|
|
|
|
}
|
|
|
|
|
|
|
|
/// visitBasicBlock - This method is called when we are visiting a new basic
|
2002-10-29 20:48:56 +00:00
|
|
|
/// block. This simply creates a new MachineBasicBlock to emit code into
|
|
|
|
/// and adds it to the current MachineFunction. Subsequent visit* for
|
|
|
|
/// instructions will be invoked for all instructions in the basic block.
|
2002-10-25 22:55:53 +00:00
|
|
|
///
|
|
|
|
void visitBasicBlock(BasicBlock &LLVM_BB) {
|
2002-10-30 00:47:40 +00:00
|
|
|
BB = new MachineBasicBlock(&LLVM_BB);
|
2002-10-25 22:55:53 +00:00
|
|
|
// FIXME: Use the auto-insert form when it's available
|
|
|
|
F->getBasicBlockList().push_back(BB);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Visitation methods for various instructions. These methods simply emit
|
|
|
|
// fixed X86 code for each instruction.
|
|
|
|
//
|
2002-11-22 11:07:01 +00:00
|
|
|
|
|
|
|
// Control flow operators
|
2002-10-25 22:55:53 +00:00
|
|
|
void visitReturnInst(ReturnInst &RI);
|
2002-11-02 19:27:56 +00:00
|
|
|
void visitBranchInst(BranchInst &BI);
|
2002-11-22 11:07:01 +00:00
|
|
|
void visitCallInst(CallInst &I);
|
2002-11-02 20:04:26 +00:00
|
|
|
|
|
|
|
// Arithmetic operators
|
2002-11-02 20:54:46 +00:00
|
|
|
void visitSimpleBinary(BinaryOperator &B, unsigned OpcodeClass);
|
2002-11-02 20:13:22 +00:00
|
|
|
void visitAdd(BinaryOperator &B) { visitSimpleBinary(B, 0); }
|
|
|
|
void visitSub(BinaryOperator &B) { visitSimpleBinary(B, 1); }
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
void doMultiply(unsigned destReg, const Type *resultType,
|
|
|
|
unsigned op0Reg, unsigned op1Reg);
|
2002-11-02 20:28:58 +00:00
|
|
|
void visitMul(BinaryOperator &B);
|
2002-11-02 20:04:26 +00:00
|
|
|
|
2002-11-02 20:54:46 +00:00
|
|
|
void visitDiv(BinaryOperator &B) { visitDivRem(B); }
|
|
|
|
void visitRem(BinaryOperator &B) { visitDivRem(B); }
|
|
|
|
void visitDivRem(BinaryOperator &B);
|
|
|
|
|
2002-11-02 20:04:26 +00:00
|
|
|
// Bitwise operators
|
2002-11-02 20:13:22 +00:00
|
|
|
void visitAnd(BinaryOperator &B) { visitSimpleBinary(B, 2); }
|
|
|
|
void visitOr (BinaryOperator &B) { visitSimpleBinary(B, 3); }
|
|
|
|
void visitXor(BinaryOperator &B) { visitSimpleBinary(B, 4); }
|
2002-11-02 20:04:26 +00:00
|
|
|
|
|
|
|
// Binary comparison operators
|
2002-11-21 15:52:38 +00:00
|
|
|
void visitSetCCInst(SetCondInst &I, unsigned OpNum);
|
|
|
|
void visitSetEQ(SetCondInst &I) { visitSetCCInst(I, 0); }
|
|
|
|
void visitSetNE(SetCondInst &I) { visitSetCCInst(I, 1); }
|
|
|
|
void visitSetLT(SetCondInst &I) { visitSetCCInst(I, 2); }
|
|
|
|
void visitSetGT(SetCondInst &I) { visitSetCCInst(I, 3); }
|
|
|
|
void visitSetLE(SetCondInst &I) { visitSetCCInst(I, 4); }
|
|
|
|
void visitSetGE(SetCondInst &I) { visitSetCCInst(I, 5); }
|
2002-11-17 21:11:55 +00:00
|
|
|
|
|
|
|
// Memory Instructions
|
|
|
|
void visitLoadInst(LoadInst &I);
|
|
|
|
void visitStoreInst(StoreInst &I);
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
void visitGetElementPtrInst(GetElementPtrInst &I);
|
|
|
|
void visitMallocInst(MallocInst &I);
|
2002-12-13 06:46:31 +00:00
|
|
|
void visitFreeInst(FreeInst &I);
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
void visitAllocaInst(AllocaInst &I);
|
|
|
|
|
2002-11-02 20:04:26 +00:00
|
|
|
// Other operators
|
2002-10-31 23:03:59 +00:00
|
|
|
void visitShiftInst(ShiftInst &I);
|
2002-11-02 20:04:26 +00:00
|
|
|
void visitPHINode(PHINode &I);
|
2002-11-22 11:07:01 +00:00
|
|
|
void visitCastInst(CastInst &I);
|
2002-10-25 22:55:53 +00:00
|
|
|
|
|
|
|
void visitInstruction(Instruction &I) {
|
|
|
|
std::cerr << "Cannot instruction select: " << I;
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2002-11-30 11:57:28 +00:00
|
|
|
void promote32 (const unsigned targetReg, Value *v);
|
2002-10-27 21:16:59 +00:00
|
|
|
|
|
|
|
/// copyConstantToRegister - Output the instructions required to put the
|
|
|
|
/// specified constant into the specified register.
|
|
|
|
///
|
|
|
|
void copyConstantToRegister(Constant *C, unsigned Reg);
|
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
/// makeAnotherReg - This method returns the next register number
|
|
|
|
/// we haven't yet used.
|
|
|
|
unsigned makeAnotherReg (void) {
|
|
|
|
unsigned Reg = CurReg++;
|
|
|
|
return Reg;
|
|
|
|
}
|
|
|
|
|
2002-10-25 22:55:53 +00:00
|
|
|
/// getReg - This method turns an LLVM value into a register number. This
|
|
|
|
/// is guaranteed to produce the same register number for a particular value
|
|
|
|
/// every time it is queried.
|
|
|
|
///
|
|
|
|
unsigned getReg(Value &V) { return getReg(&V); } // Allow references
|
|
|
|
unsigned getReg(Value *V) {
|
|
|
|
unsigned &Reg = RegMap[V];
|
2002-11-20 00:58:23 +00:00
|
|
|
if (Reg == 0) {
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
Reg = makeAnotherReg ();
|
2002-11-20 00:58:23 +00:00
|
|
|
RegMap[V] = Reg;
|
|
|
|
|
|
|
|
// Add the mapping of regnumber => reg class to MachineFunction
|
|
|
|
F->addRegMap(Reg,
|
|
|
|
TM.getRegisterInfo()->getRegClassForType(V->getType()));
|
|
|
|
}
|
2002-10-25 22:55:53 +00:00
|
|
|
|
2002-10-27 21:23:43 +00:00
|
|
|
// If this operand is a constant, emit the code to copy the constant into
|
|
|
|
// the register here...
|
|
|
|
//
|
2002-12-04 06:45:19 +00:00
|
|
|
if (Constant *C = dyn_cast<Constant>(V)) {
|
2002-10-27 21:16:59 +00:00
|
|
|
copyConstantToRegister(C, Reg);
|
2002-12-04 06:45:19 +00:00
|
|
|
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
|
|
|
|
// Move the address of the global into the register
|
|
|
|
BuildMI(BB, X86::MOVir32, 1, Reg).addReg(GV);
|
2002-12-04 17:15:34 +00:00
|
|
|
} else if (Argument *A = dyn_cast<Argument>(V)) {
|
|
|
|
std::cerr << "ERROR: Arguments not implemented in SimpleInstSel\n";
|
2002-12-04 06:45:19 +00:00
|
|
|
}
|
2002-10-27 21:16:59 +00:00
|
|
|
|
2002-10-25 22:55:53 +00:00
|
|
|
return Reg;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2002-11-17 20:07:45 +00:00
|
|
|
/// TypeClass - Used by the X86 backend to group LLVM types by their basic X86
|
|
|
|
/// Representation.
|
|
|
|
///
|
|
|
|
enum TypeClass {
|
|
|
|
cByte, cShort, cInt, cLong, cFloat, cDouble
|
|
|
|
};
|
|
|
|
|
2002-11-02 01:15:18 +00:00
|
|
|
/// getClass - Turn a primitive type into a "class" number which is based on the
|
|
|
|
/// size of the type, and whether or not it is floating point.
|
|
|
|
///
|
2002-11-17 20:07:45 +00:00
|
|
|
static inline TypeClass getClass(const Type *Ty) {
|
2002-11-02 01:15:18 +00:00
|
|
|
switch (Ty->getPrimitiveID()) {
|
|
|
|
case Type::SByteTyID:
|
2002-11-17 20:07:45 +00:00
|
|
|
case Type::UByteTyID: return cByte; // Byte operands are class #0
|
2002-11-02 01:15:18 +00:00
|
|
|
case Type::ShortTyID:
|
2002-11-17 20:07:45 +00:00
|
|
|
case Type::UShortTyID: return cShort; // Short operands are class #1
|
2002-11-02 01:15:18 +00:00
|
|
|
case Type::IntTyID:
|
|
|
|
case Type::UIntTyID:
|
2002-11-17 20:07:45 +00:00
|
|
|
case Type::PointerTyID: return cInt; // Int's and pointers are class #2
|
2002-11-02 01:15:18 +00:00
|
|
|
|
|
|
|
case Type::LongTyID:
|
2002-11-17 20:07:45 +00:00
|
|
|
case Type::ULongTyID: return cLong; // Longs are class #3
|
|
|
|
case Type::FloatTyID: return cFloat; // Float is class #4
|
|
|
|
case Type::DoubleTyID: return cDouble; // Doubles are class #5
|
2002-11-02 01:15:18 +00:00
|
|
|
default:
|
|
|
|
assert(0 && "Invalid type to getClass!");
|
2002-11-17 20:07:45 +00:00
|
|
|
return cByte; // not reached
|
2002-11-02 01:15:18 +00:00
|
|
|
}
|
|
|
|
}
|
2002-10-27 21:16:59 +00:00
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-10-27 21:16:59 +00:00
|
|
|
/// copyConstantToRegister - Output the instructions required to put the
|
|
|
|
/// specified constant into the specified register.
|
|
|
|
///
|
|
|
|
void ISel::copyConstantToRegister(Constant *C, unsigned R) {
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
if (isa<ConstantExpr> (C)) {
|
|
|
|
// FIXME: We really need to handle getelementptr exprs, among
|
|
|
|
// other things.
|
|
|
|
std::cerr << "Offending expr: " << C << "\n";
|
|
|
|
}
|
2002-10-27 21:16:59 +00:00
|
|
|
assert (!isa<ConstantExpr>(C) && "Constant expressions not yet handled!\n");
|
|
|
|
|
2002-11-02 01:15:18 +00:00
|
|
|
if (C->getType()->isIntegral()) {
|
|
|
|
unsigned Class = getClass(C->getType());
|
|
|
|
assert(Class != 3 && "Type not handled yet!");
|
|
|
|
|
|
|
|
static const unsigned IntegralOpcodeTab[] = {
|
|
|
|
X86::MOVir8, X86::MOVir16, X86::MOVir32
|
|
|
|
};
|
|
|
|
|
|
|
|
if (C->getType()->isSigned()) {
|
|
|
|
ConstantSInt *CSI = cast<ConstantSInt>(C);
|
|
|
|
BuildMI(BB, IntegralOpcodeTab[Class], 1, R).addSImm(CSI->getValue());
|
|
|
|
} else {
|
|
|
|
ConstantUInt *CUI = cast<ConstantUInt>(C);
|
|
|
|
BuildMI(BB, IntegralOpcodeTab[Class], 1, R).addZImm(CUI->getValue());
|
|
|
|
}
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
} else if (isa <ConstantPointerNull> (C)) {
|
|
|
|
// Copy zero (null pointer) to the register.
|
|
|
|
BuildMI (BB, X86::MOVir32, 1, R).addZImm(0);
|
2002-11-02 01:15:18 +00:00
|
|
|
} else {
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
std::cerr << "Offending constant: " << C << "\n";
|
2002-11-02 01:15:18 +00:00
|
|
|
assert(0 && "Type not handled yet!");
|
2002-10-27 21:16:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-11-07 17:59:21 +00:00
|
|
|
/// SetCC instructions - Here we just emit boilerplate code to set a byte-sized
|
|
|
|
/// register, then move it to wherever the result should be.
|
|
|
|
/// We handle FP setcc instructions by pushing them, doing a
|
|
|
|
/// compare-and-pop-twice, and then copying the concodes to the main
|
|
|
|
/// processor's concodes (I didn't make this up, it's in the Intel manual)
|
|
|
|
///
|
2002-11-21 15:52:38 +00:00
|
|
|
void ISel::visitSetCCInst(SetCondInst &I, unsigned OpNum) {
|
2002-11-07 17:59:21 +00:00
|
|
|
// The arguments are already supposed to be of the same type.
|
2002-11-21 15:52:38 +00:00
|
|
|
const Type *CompTy = I.getOperand(0)->getType();
|
|
|
|
unsigned reg1 = getReg(I.getOperand(0));
|
|
|
|
unsigned reg2 = getReg(I.getOperand(1));
|
|
|
|
|
|
|
|
unsigned Class = getClass(CompTy);
|
|
|
|
switch (Class) {
|
|
|
|
// Emit: cmp <var1>, <var2> (do the comparison). We can
|
|
|
|
// compare 8-bit with 8-bit, 16-bit with 16-bit, 32-bit with
|
|
|
|
// 32-bit.
|
|
|
|
case cByte:
|
|
|
|
BuildMI (BB, X86::CMPrr8, 2).addReg (reg1).addReg (reg2);
|
|
|
|
break;
|
|
|
|
case cShort:
|
|
|
|
BuildMI (BB, X86::CMPrr16, 2).addReg (reg1).addReg (reg2);
|
|
|
|
break;
|
|
|
|
case cInt:
|
|
|
|
BuildMI (BB, X86::CMPrr32, 2).addReg (reg1).addReg (reg2);
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Push the variables on the stack with fldl opcodes.
|
|
|
|
// FIXME: assuming var1, var2 are in memory, if not, spill to
|
|
|
|
// stack first
|
|
|
|
case cFloat: // Floats
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
BuildMI (BB, X86::FLDr32, 1).addReg (reg1);
|
|
|
|
BuildMI (BB, X86::FLDr32, 1).addReg (reg2);
|
2002-11-21 15:52:38 +00:00
|
|
|
break;
|
|
|
|
case cDouble: // Doubles
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
BuildMI (BB, X86::FLDr64, 1).addReg (reg1);
|
|
|
|
BuildMI (BB, X86::FLDr64, 1).addReg (reg2);
|
2002-11-21 15:52:38 +00:00
|
|
|
break;
|
|
|
|
case cLong:
|
|
|
|
default:
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (CompTy->isFloatingPoint()) {
|
|
|
|
// (Non-trapping) compare and pop twice.
|
|
|
|
BuildMI (BB, X86::FUCOMPP, 0);
|
|
|
|
// Move fp status word (concodes) to ax.
|
|
|
|
BuildMI (BB, X86::FNSTSWr8, 1, X86::AX);
|
|
|
|
// Load real concodes from ax.
|
|
|
|
BuildMI (BB, X86::SAHF, 1).addReg(X86::AH);
|
|
|
|
}
|
|
|
|
|
2002-11-07 17:59:21 +00:00
|
|
|
// Emit setOp instruction (extract concode; clobbers ax),
|
|
|
|
// using the following mapping:
|
|
|
|
// LLVM -> X86 signed X86 unsigned
|
|
|
|
// ----- ----- -----
|
|
|
|
// seteq -> sete sete
|
|
|
|
// setne -> setne setne
|
|
|
|
// setlt -> setl setb
|
|
|
|
// setgt -> setg seta
|
|
|
|
// setle -> setle setbe
|
|
|
|
// setge -> setge setae
|
2002-11-21 15:52:38 +00:00
|
|
|
|
|
|
|
static const unsigned OpcodeTab[2][6] = {
|
2002-11-21 16:19:42 +00:00
|
|
|
{X86::SETEr, X86::SETNEr, X86::SETBr, X86::SETAr, X86::SETBEr, X86::SETAEr},
|
|
|
|
{X86::SETEr, X86::SETNEr, X86::SETLr, X86::SETGr, X86::SETLEr, X86::SETGEr},
|
2002-11-21 15:52:38 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
BuildMI(BB, OpcodeTab[CompTy->isSigned()][OpNum], 0, X86::AL);
|
|
|
|
|
2002-11-07 17:59:21 +00:00
|
|
|
// Put it in the result using a move.
|
2002-11-21 15:52:38 +00:00
|
|
|
BuildMI (BB, X86::MOVrr8, 1, getReg(I)).addReg(X86::AL);
|
2002-11-07 17:59:21 +00:00
|
|
|
}
|
2002-11-02 19:45:49 +00:00
|
|
|
|
2002-11-30 11:57:28 +00:00
|
|
|
/// promote32 - Emit instructions to turn a narrow operand into a 32-bit-wide
|
|
|
|
/// operand, in the specified target register.
|
|
|
|
void
|
|
|
|
ISel::promote32 (const unsigned targetReg, Value *v)
|
|
|
|
{
|
|
|
|
unsigned vReg = getReg (v);
|
|
|
|
unsigned Class = getClass (v->getType ());
|
|
|
|
bool isUnsigned = v->getType ()->isUnsigned ();
|
|
|
|
assert (((Class == cByte) || (Class == cShort) || (Class == cInt))
|
|
|
|
&& "Unpromotable operand class in promote32");
|
|
|
|
switch (Class)
|
|
|
|
{
|
|
|
|
case cByte:
|
|
|
|
// Extend value into target register (8->32)
|
|
|
|
if (isUnsigned)
|
|
|
|
BuildMI (BB, X86::MOVZXr32r8, 1, targetReg).addReg (vReg);
|
|
|
|
else
|
|
|
|
BuildMI (BB, X86::MOVSXr32r8, 1, targetReg).addReg (vReg);
|
|
|
|
break;
|
|
|
|
case cShort:
|
|
|
|
// Extend value into target register (16->32)
|
|
|
|
if (isUnsigned)
|
|
|
|
BuildMI (BB, X86::MOVZXr32r16, 1, targetReg).addReg (vReg);
|
|
|
|
else
|
|
|
|
BuildMI (BB, X86::MOVSXr32r16, 1, targetReg).addReg (vReg);
|
|
|
|
break;
|
|
|
|
case cInt:
|
|
|
|
// Move value into target register (32->32)
|
|
|
|
BuildMI (BB, X86::MOVrr32, 1, targetReg).addReg (vReg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2002-10-27 21:16:59 +00:00
|
|
|
|
2002-10-25 22:55:53 +00:00
|
|
|
/// 'ret' instruction - Here we are interested in meeting the x86 ABI. As such,
|
|
|
|
/// we have the following possibilities:
|
|
|
|
///
|
|
|
|
/// ret void: No return value, simply emit a 'ret' instruction
|
|
|
|
/// ret sbyte, ubyte : Extend value into EAX and return
|
|
|
|
/// ret short, ushort: Extend value into EAX and return
|
|
|
|
/// ret int, uint : Move value into EAX and return
|
|
|
|
/// ret pointer : Move value into EAX and return
|
2002-11-17 21:56:38 +00:00
|
|
|
/// ret long, ulong : Move value into EAX/EDX and return
|
|
|
|
/// ret float/double : Top of FP stack
|
2002-10-25 22:55:53 +00:00
|
|
|
///
|
2002-11-30 11:57:28 +00:00
|
|
|
void
|
|
|
|
ISel::visitReturnInst (ReturnInst &I)
|
|
|
|
{
|
|
|
|
if (I.getNumOperands () == 0)
|
|
|
|
{
|
|
|
|
// Emit a 'ret' instruction
|
|
|
|
BuildMI (BB, X86::RET, 0);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
Value *rv = I.getOperand (0);
|
|
|
|
unsigned Class = getClass (rv->getType ());
|
|
|
|
switch (Class)
|
|
|
|
{
|
|
|
|
// integral return values: extend or move into EAX and return.
|
|
|
|
case cByte:
|
|
|
|
case cShort:
|
|
|
|
case cInt:
|
|
|
|
promote32 (X86::EAX, rv);
|
|
|
|
break;
|
|
|
|
// ret float/double: top of FP stack
|
|
|
|
// FLD <val>
|
|
|
|
case cFloat: // Floats
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
BuildMI (BB, X86::FLDr32, 1).addReg (getReg (rv));
|
2002-11-30 11:57:28 +00:00
|
|
|
break;
|
|
|
|
case cDouble: // Doubles
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
BuildMI (BB, X86::FLDr64, 1).addReg (getReg (rv));
|
2002-11-30 11:57:28 +00:00
|
|
|
break;
|
|
|
|
case cLong:
|
|
|
|
// ret long: use EAX(least significant 32 bits)/EDX (most
|
|
|
|
// significant 32)...uh, I think so Brain, but how do i call
|
|
|
|
// up the two parts of the value from inside this mouse
|
|
|
|
// cage? *zort*
|
|
|
|
default:
|
|
|
|
visitInstruction (I);
|
|
|
|
}
|
2002-11-17 20:07:45 +00:00
|
|
|
// Emit a 'ret' instruction
|
2002-11-30 11:57:28 +00:00
|
|
|
BuildMI (BB, X86::RET, 0);
|
2002-10-25 22:55:53 +00:00
|
|
|
}
|
|
|
|
|
2002-11-02 19:45:49 +00:00
|
|
|
/// visitBranchInst - Handle conditional and unconditional branches here. Note
|
|
|
|
/// that since code layout is frozen at this point, that if we are trying to
|
|
|
|
/// jump to a block that is the immediate successor of the current block, we can
|
|
|
|
/// just make a fall-through. (but we don't currently).
|
|
|
|
///
|
2002-11-19 09:08:47 +00:00
|
|
|
void
|
|
|
|
ISel::visitBranchInst (BranchInst & BI)
|
|
|
|
{
|
|
|
|
if (BI.isConditional ())
|
|
|
|
{
|
|
|
|
BasicBlock *ifTrue = BI.getSuccessor (0);
|
|
|
|
BasicBlock *ifFalse = BI.getSuccessor (1); // this is really unobvious
|
|
|
|
|
|
|
|
// simplest thing I can think of: compare condition with zero,
|
|
|
|
// followed by jump-if-equal to ifFalse, and jump-if-nonequal to
|
|
|
|
// ifTrue
|
|
|
|
unsigned int condReg = getReg (BI.getCondition ());
|
2002-11-21 01:59:50 +00:00
|
|
|
BuildMI (BB, X86::CMPri8, 2).addReg (condReg).addZImm (0);
|
2002-11-19 09:08:47 +00:00
|
|
|
BuildMI (BB, X86::JNE, 1).addPCDisp (BI.getSuccessor (0));
|
|
|
|
BuildMI (BB, X86::JE, 1).addPCDisp (BI.getSuccessor (1));
|
|
|
|
}
|
|
|
|
else // unconditional branch
|
|
|
|
{
|
|
|
|
BuildMI (BB, X86::JMP, 1).addPCDisp (BI.getSuccessor (0));
|
|
|
|
}
|
2002-11-02 19:27:56 +00:00
|
|
|
}
|
|
|
|
|
2002-11-29 12:01:58 +00:00
|
|
|
/// visitCallInst - Push args on stack and do a procedure call instruction.
|
|
|
|
void
|
|
|
|
ISel::visitCallInst (CallInst & CI)
|
|
|
|
{
|
2002-12-04 19:22:53 +00:00
|
|
|
// keep a counter of how many bytes we pushed on the stack
|
|
|
|
unsigned bytesPushed = 0;
|
|
|
|
|
2002-11-29 12:01:58 +00:00
|
|
|
// Push the arguments on the stack in reverse order, as specified by
|
|
|
|
// the ABI.
|
2002-12-03 20:30:12 +00:00
|
|
|
for (unsigned i = CI.getNumOperands()-1; i >= 1; --i)
|
2002-11-29 12:01:58 +00:00
|
|
|
{
|
|
|
|
Value *v = CI.getOperand (i);
|
|
|
|
switch (getClass (v->getType ()))
|
|
|
|
{
|
2002-11-30 11:57:28 +00:00
|
|
|
case cByte:
|
|
|
|
case cShort:
|
2002-12-03 00:51:09 +00:00
|
|
|
// Promote V to 32 bits wide, and move the result into EAX,
|
|
|
|
// then push EAX.
|
2002-11-30 11:57:28 +00:00
|
|
|
promote32 (X86::EAX, v);
|
|
|
|
BuildMI (BB, X86::PUSHr32, 1).addReg (X86::EAX);
|
2002-12-04 19:22:53 +00:00
|
|
|
bytesPushed += 4;
|
2002-11-30 11:57:28 +00:00
|
|
|
break;
|
2002-11-29 12:01:58 +00:00
|
|
|
case cInt:
|
2002-12-04 06:56:56 +00:00
|
|
|
case cFloat: {
|
|
|
|
unsigned Reg = getReg(v);
|
|
|
|
BuildMI (BB, X86::PUSHr32, 1).addReg(Reg);
|
2002-12-04 19:22:53 +00:00
|
|
|
bytesPushed += 4;
|
2002-11-29 12:01:58 +00:00
|
|
|
break;
|
2002-12-04 06:56:56 +00:00
|
|
|
}
|
2002-11-29 12:01:58 +00:00
|
|
|
default:
|
2002-12-03 00:51:09 +00:00
|
|
|
// FIXME: long/ulong/double args not handled.
|
2002-11-29 12:01:58 +00:00
|
|
|
visitInstruction (CI);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Emit a CALL instruction with PC-relative displacement.
|
|
|
|
BuildMI (BB, X86::CALLpcrel32, 1).addPCDisp (CI.getCalledValue ());
|
2002-12-04 19:22:53 +00:00
|
|
|
|
|
|
|
// Adjust the stack by `bytesPushed' amount if non-zero
|
|
|
|
if (bytesPushed > 0)
|
|
|
|
BuildMI (BB, X86::ADDri32, 2).addReg(X86::ESP).addZImm(bytesPushed);
|
2002-12-04 23:45:28 +00:00
|
|
|
|
|
|
|
// If there is a return value, scavenge the result from the location the call
|
|
|
|
// leaves it in...
|
|
|
|
//
|
2002-12-04 23:50:28 +00:00
|
|
|
if (CI.getType() != Type::VoidTy) {
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
unsigned resultTypeClass = getClass (CI.getType ());
|
|
|
|
switch (resultTypeClass) {
|
|
|
|
case cByte:
|
|
|
|
case cShort:
|
|
|
|
case cInt: {
|
|
|
|
// Integral results are in %eax, or the appropriate portion
|
|
|
|
// thereof.
|
|
|
|
static const unsigned regRegMove[] = {
|
|
|
|
X86::MOVrr8, X86::MOVrr16, X86::MOVrr32
|
|
|
|
};
|
|
|
|
static const unsigned AReg[] = { X86::AL, X86::AX, X86::EAX };
|
|
|
|
BuildMI (BB, regRegMove[resultTypeClass], 1,
|
|
|
|
getReg (CI)).addReg (AReg[resultTypeClass]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case cFloat:
|
|
|
|
// Floating-point return values live in %st(0) (i.e., the top of
|
|
|
|
// the FP stack.) The general way to approach this is to do a
|
|
|
|
// FSTP to save the top of the FP stack on the real stack, then
|
|
|
|
// do a MOV to load the top of the real stack into the target
|
|
|
|
// register.
|
|
|
|
visitInstruction (CI); // FIXME: add the right args for the calls below
|
|
|
|
// BuildMI (BB, X86::FSTPm32, 0);
|
|
|
|
// BuildMI (BB, X86::MOVmr32, 0);
|
2002-12-04 23:50:28 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
std::cerr << "Cannot get return value for call of type '"
|
|
|
|
<< *CI.getType() << "'\n";
|
|
|
|
visitInstruction(CI);
|
|
|
|
}
|
2002-12-04 23:45:28 +00:00
|
|
|
}
|
2002-11-22 11:07:01 +00:00
|
|
|
}
|
2002-11-02 19:27:56 +00:00
|
|
|
|
2002-11-02 20:13:22 +00:00
|
|
|
/// visitSimpleBinary - Implement simple binary operators for integral types...
|
|
|
|
/// OperatorClass is one of: 0 for Add, 1 for Sub, 2 for And, 3 for Or,
|
|
|
|
/// 4 for Xor.
|
|
|
|
///
|
|
|
|
void ISel::visitSimpleBinary(BinaryOperator &B, unsigned OperatorClass) {
|
|
|
|
if (B.getType() == Type::BoolTy) // FIXME: Handle bools for logicals
|
2002-11-02 20:04:26 +00:00
|
|
|
visitInstruction(B);
|
|
|
|
|
|
|
|
unsigned Class = getClass(B.getType());
|
|
|
|
if (Class > 2) // FIXME: Handle longs
|
|
|
|
visitInstruction(B);
|
|
|
|
|
|
|
|
static const unsigned OpcodeTab[][4] = {
|
2002-11-02 20:13:22 +00:00
|
|
|
// Arithmetic operators
|
|
|
|
{ X86::ADDrr8, X86::ADDrr16, X86::ADDrr32, 0 }, // ADD
|
|
|
|
{ X86::SUBrr8, X86::SUBrr16, X86::SUBrr32, 0 }, // SUB
|
|
|
|
|
|
|
|
// Bitwise operators
|
2002-11-02 20:04:26 +00:00
|
|
|
{ X86::ANDrr8, X86::ANDrr16, X86::ANDrr32, 0 }, // AND
|
|
|
|
{ X86:: ORrr8, X86:: ORrr16, X86:: ORrr32, 0 }, // OR
|
|
|
|
{ X86::XORrr8, X86::XORrr16, X86::XORrr32, 0 }, // XOR
|
|
|
|
};
|
|
|
|
|
|
|
|
unsigned Opcode = OpcodeTab[OperatorClass][Class];
|
|
|
|
unsigned Op0r = getReg(B.getOperand(0));
|
|
|
|
unsigned Op1r = getReg(B.getOperand(1));
|
|
|
|
BuildMI(BB, Opcode, 2, getReg(B)).addReg(Op0r).addReg(Op1r);
|
|
|
|
}
|
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
/// doMultiply - Emit appropriate instructions to multiply together
|
|
|
|
/// the registers op0Reg and op1Reg, and put the result in destReg.
|
|
|
|
/// The type of the result should be given as resultType.
|
|
|
|
void
|
|
|
|
ISel::doMultiply(unsigned destReg, const Type *resultType,
|
|
|
|
unsigned op0Reg, unsigned op1Reg)
|
|
|
|
{
|
|
|
|
unsigned Class = getClass (resultType);
|
2002-11-02 20:28:58 +00:00
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
// FIXME:
|
|
|
|
assert (Class <= 2 && "Someday, we will learn how to multiply"
|
|
|
|
"longs and floating-point numbers. This is not that day.");
|
|
|
|
|
2002-11-02 20:28:58 +00:00
|
|
|
static const unsigned Regs[] ={ X86::AL , X86::AX , X86::EAX };
|
|
|
|
static const unsigned MulOpcode[]={ X86::MULrr8, X86::MULrr16, X86::MULrr32 };
|
|
|
|
static const unsigned MovOpcode[]={ X86::MOVrr8, X86::MOVrr16, X86::MOVrr32 };
|
2002-11-17 21:56:38 +00:00
|
|
|
unsigned Reg = Regs[Class];
|
2002-11-02 20:04:26 +00:00
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
// Emit a MOV to put the first operand into the appropriately-sized
|
|
|
|
// subreg of EAX.
|
|
|
|
BuildMI (BB, MovOpcode[Class], 1, Reg).addReg (op0Reg);
|
2002-11-02 20:28:58 +00:00
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
// Emit the appropriate multiply instruction.
|
|
|
|
BuildMI (BB, MulOpcode[Class], 1).addReg (op1Reg);
|
2002-11-02 20:28:58 +00:00
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
// Emit another MOV to put the result into the destination register.
|
|
|
|
BuildMI (BB, MovOpcode[Class], 1, destReg).addReg (Reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// visitMul - Multiplies are not simple binary operators because they must deal
|
|
|
|
/// with the EAX register explicitly.
|
|
|
|
///
|
|
|
|
void ISel::visitMul(BinaryOperator &I) {
|
|
|
|
doMultiply (getReg (I), I.getType (),
|
|
|
|
getReg (I.getOperand (0)), getReg (I.getOperand (1)));
|
2002-11-02 20:54:46 +00:00
|
|
|
}
|
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-11-02 20:54:46 +00:00
|
|
|
/// visitDivRem - Handle division and remainder instructions... these
|
|
|
|
/// instruction both require the same instructions to be generated, they just
|
|
|
|
/// select the result from a different register. Note that both of these
|
|
|
|
/// instructions work differently for signed and unsigned operands.
|
|
|
|
///
|
|
|
|
void ISel::visitDivRem(BinaryOperator &I) {
|
|
|
|
unsigned Class = getClass(I.getType());
|
|
|
|
if (Class > 2) // FIXME: Handle longs
|
|
|
|
visitInstruction(I);
|
|
|
|
|
|
|
|
static const unsigned Regs[] ={ X86::AL , X86::AX , X86::EAX };
|
|
|
|
static const unsigned MovOpcode[]={ X86::MOVrr8, X86::MOVrr16, X86::MOVrr32 };
|
2002-11-14 22:32:30 +00:00
|
|
|
static const unsigned ExtOpcode[]={ X86::CBW , X86::CWD , X86::CDQ };
|
2002-11-02 20:54:46 +00:00
|
|
|
static const unsigned ClrOpcode[]={ X86::XORrr8, X86::XORrr16, X86::XORrr32 };
|
|
|
|
static const unsigned ExtRegs[] ={ X86::AH , X86::DX , X86::EDX };
|
|
|
|
|
|
|
|
static const unsigned DivOpcode[][4] = {
|
|
|
|
{ X86::DIVrr8 , X86::DIVrr16 , X86::DIVrr32 , 0 }, // Unsigned division
|
|
|
|
{ X86::IDIVrr8, X86::IDIVrr16, X86::IDIVrr32, 0 }, // Signed division
|
|
|
|
};
|
2002-11-02 20:28:58 +00:00
|
|
|
|
2002-11-02 20:54:46 +00:00
|
|
|
bool isSigned = I.getType()->isSigned();
|
|
|
|
unsigned Reg = Regs[Class];
|
|
|
|
unsigned ExtReg = ExtRegs[Class];
|
2002-11-17 21:11:55 +00:00
|
|
|
unsigned Op0Reg = getReg(I.getOperand(0));
|
2002-11-02 20:54:46 +00:00
|
|
|
unsigned Op1Reg = getReg(I.getOperand(1));
|
|
|
|
|
|
|
|
// Put the first operand into one of the A registers...
|
|
|
|
BuildMI(BB, MovOpcode[Class], 1, Reg).addReg(Op0Reg);
|
|
|
|
|
|
|
|
if (isSigned) {
|
|
|
|
// Emit a sign extension instruction...
|
2002-12-01 23:24:58 +00:00
|
|
|
BuildMI(BB, ExtOpcode[Class], 0);
|
2002-11-02 20:54:46 +00:00
|
|
|
} else {
|
|
|
|
// If unsigned, emit a zeroing instruction... (reg = xor reg, reg)
|
|
|
|
BuildMI(BB, ClrOpcode[Class], 2, ExtReg).addReg(ExtReg).addReg(ExtReg);
|
|
|
|
}
|
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
// Emit the appropriate divide or remainder instruction...
|
2002-11-21 18:54:29 +00:00
|
|
|
BuildMI(BB, DivOpcode[isSigned][Class], 1).addReg(Op1Reg);
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-11-02 20:54:46 +00:00
|
|
|
// Figure out which register we want to pick the result out of...
|
|
|
|
unsigned DestReg = (I.getOpcode() == Instruction::Div) ? Reg : ExtReg;
|
|
|
|
|
|
|
|
// Put the result into the destination register...
|
|
|
|
BuildMI(BB, MovOpcode[Class], 1, getReg(I)).addReg(DestReg);
|
2002-11-02 20:28:58 +00:00
|
|
|
}
|
2002-11-02 20:04:26 +00:00
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-10-31 23:03:59 +00:00
|
|
|
/// Shift instructions: 'shl', 'sar', 'shr' - Some special cases here
|
|
|
|
/// for constant immediate shift values, and for constant immediate
|
|
|
|
/// shift values equal to 1. Even the general case is sort of special,
|
|
|
|
/// because the shift amount has to be in CL, not just any old register.
|
|
|
|
///
|
2002-11-02 20:54:46 +00:00
|
|
|
void ISel::visitShiftInst (ShiftInst &I) {
|
|
|
|
unsigned Op0r = getReg (I.getOperand(0));
|
|
|
|
unsigned DestReg = getReg(I);
|
2002-11-02 01:41:55 +00:00
|
|
|
bool isLeftShift = I.getOpcode() == Instruction::Shl;
|
|
|
|
bool isOperandSigned = I.getType()->isUnsigned();
|
2002-11-02 01:15:18 +00:00
|
|
|
unsigned OperandClass = getClass(I.getType());
|
|
|
|
|
|
|
|
if (OperandClass > 2)
|
|
|
|
visitInstruction(I); // Can't handle longs yet!
|
2002-11-02 00:44:25 +00:00
|
|
|
|
2002-10-31 23:03:59 +00:00
|
|
|
if (ConstantUInt *CUI = dyn_cast <ConstantUInt> (I.getOperand (1)))
|
|
|
|
{
|
2002-11-02 00:44:25 +00:00
|
|
|
// The shift amount is constant, guaranteed to be a ubyte. Get its value.
|
|
|
|
assert(CUI->getType() == Type::UByteTy && "Shift amount not a ubyte?");
|
|
|
|
unsigned char shAmt = CUI->getValue();
|
|
|
|
|
2002-11-02 01:41:55 +00:00
|
|
|
static const unsigned ConstantOperand[][4] = {
|
|
|
|
{ X86::SHRir8, X86::SHRir16, X86::SHRir32, 0 }, // SHR
|
|
|
|
{ X86::SARir8, X86::SARir16, X86::SARir32, 0 }, // SAR
|
|
|
|
{ X86::SHLir8, X86::SHLir16, X86::SHLir32, 0 }, // SHL
|
|
|
|
{ X86::SHLir8, X86::SHLir16, X86::SHLir32, 0 }, // SAL = SHL
|
2002-11-02 01:15:18 +00:00
|
|
|
};
|
|
|
|
|
2002-11-02 01:41:55 +00:00
|
|
|
const unsigned *OpTab = // Figure out the operand table to use
|
|
|
|
ConstantOperand[isLeftShift*2+isOperandSigned];
|
2002-11-02 01:15:18 +00:00
|
|
|
|
2002-10-31 23:03:59 +00:00
|
|
|
// Emit: <insn> reg, shamt (shift-by-immediate opcode "ir" form.)
|
2002-11-02 01:15:18 +00:00
|
|
|
BuildMI(BB, OpTab[OperandClass], 2, DestReg).addReg(Op0r).addZImm(shAmt);
|
2002-10-31 23:03:59 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// The shift amount is non-constant.
|
|
|
|
//
|
|
|
|
// In fact, you can only shift with a variable shift amount if
|
|
|
|
// that amount is already in the CL register, so we have to put it
|
|
|
|
// there first.
|
|
|
|
//
|
2002-11-02 01:41:55 +00:00
|
|
|
|
2002-10-31 23:03:59 +00:00
|
|
|
// Emit: move cl, shiftAmount (put the shift amount in CL.)
|
2002-11-02 20:28:58 +00:00
|
|
|
BuildMI(BB, X86::MOVrr8, 1, X86::CL).addReg(getReg(I.getOperand(1)));
|
2002-11-02 01:15:18 +00:00
|
|
|
|
|
|
|
// This is a shift right (SHR).
|
2002-11-02 01:41:55 +00:00
|
|
|
static const unsigned NonConstantOperand[][4] = {
|
|
|
|
{ X86::SHRrr8, X86::SHRrr16, X86::SHRrr32, 0 }, // SHR
|
|
|
|
{ X86::SARrr8, X86::SARrr16, X86::SARrr32, 0 }, // SAR
|
|
|
|
{ X86::SHLrr8, X86::SHLrr16, X86::SHLrr32, 0 }, // SHL
|
|
|
|
{ X86::SHLrr8, X86::SHLrr16, X86::SHLrr32, 0 }, // SAL = SHL
|
2002-11-02 01:15:18 +00:00
|
|
|
};
|
|
|
|
|
2002-11-02 01:41:55 +00:00
|
|
|
const unsigned *OpTab = // Figure out the operand table to use
|
|
|
|
NonConstantOperand[isLeftShift*2+isOperandSigned];
|
2002-11-02 01:15:18 +00:00
|
|
|
|
2002-11-21 22:49:20 +00:00
|
|
|
BuildMI(BB, OpTab[OperandClass], 1, DestReg).addReg(Op0r);
|
2002-10-31 23:03:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-11-17 21:11:55 +00:00
|
|
|
/// visitLoadInst - Implement LLVM load instructions in terms of the x86 'mov'
|
|
|
|
/// instruction.
|
|
|
|
///
|
|
|
|
void ISel::visitLoadInst(LoadInst &I) {
|
|
|
|
unsigned Class = getClass(I.getType());
|
|
|
|
if (Class > 2) // FIXME: Handle longs and others...
|
|
|
|
visitInstruction(I);
|
|
|
|
|
|
|
|
static const unsigned Opcode[] = { X86::MOVmr8, X86::MOVmr16, X86::MOVmr32 };
|
|
|
|
|
|
|
|
unsigned AddressReg = getReg(I.getOperand(0));
|
|
|
|
addDirectMem(BuildMI(BB, Opcode[Class], 4, getReg(I)), AddressReg);
|
|
|
|
}
|
|
|
|
|
2002-11-17 21:56:38 +00:00
|
|
|
|
2002-11-17 21:11:55 +00:00
|
|
|
/// visitStoreInst - Implement LLVM store instructions in terms of the x86 'mov'
|
|
|
|
/// instruction.
|
|
|
|
///
|
|
|
|
void ISel::visitStoreInst(StoreInst &I) {
|
|
|
|
unsigned Class = getClass(I.getOperand(0)->getType());
|
|
|
|
if (Class > 2) // FIXME: Handle longs and others...
|
|
|
|
visitInstruction(I);
|
|
|
|
|
|
|
|
static const unsigned Opcode[] = { X86::MOVrm8, X86::MOVrm16, X86::MOVrm32 };
|
|
|
|
|
|
|
|
unsigned ValReg = getReg(I.getOperand(0));
|
|
|
|
unsigned AddressReg = getReg(I.getOperand(1));
|
|
|
|
addDirectMem(BuildMI(BB, Opcode[Class], 1+4), AddressReg).addReg(ValReg);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-11-02 20:04:26 +00:00
|
|
|
/// visitPHINode - Turn an LLVM PHI node into an X86 PHI node...
|
|
|
|
///
|
|
|
|
void ISel::visitPHINode(PHINode &PN) {
|
|
|
|
MachineInstr *MI = BuildMI(BB, X86::PHI, PN.getNumOperands(), getReg(PN));
|
2002-10-25 22:55:53 +00:00
|
|
|
|
2002-11-02 20:04:26 +00:00
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
|
|
|
|
// FIXME: This will put constants after the PHI nodes in the block, which
|
|
|
|
// is invalid. They should be put inline into the PHI node eventually.
|
|
|
|
//
|
|
|
|
MI->addRegOperand(getReg(PN.getIncomingValue(i)));
|
|
|
|
MI->addPCDispOperand(PN.getIncomingBlock(i));
|
|
|
|
}
|
2002-10-25 22:55:53 +00:00
|
|
|
}
|
|
|
|
|
2002-11-26 10:43:30 +00:00
|
|
|
/// visitCastInst - Here we have various kinds of copying with or without
|
|
|
|
/// sign extension going on.
|
2002-11-22 11:07:01 +00:00
|
|
|
void
|
|
|
|
ISel::visitCastInst (CastInst &CI)
|
|
|
|
{
|
2002-12-03 18:15:59 +00:00
|
|
|
const Type *targetType = CI.getType ();
|
2002-12-03 07:36:03 +00:00
|
|
|
Value *operand = CI.getOperand (0);
|
|
|
|
unsigned int operandReg = getReg (operand);
|
2002-12-03 18:15:59 +00:00
|
|
|
const Type *sourceType = operand->getType ();
|
2002-12-03 07:36:03 +00:00
|
|
|
unsigned int destReg = getReg (CI);
|
2002-12-06 10:49:33 +00:00
|
|
|
//
|
|
|
|
// Currently we handle:
|
|
|
|
//
|
|
|
|
// 1) cast * to bool
|
|
|
|
//
|
|
|
|
// 2) cast {sbyte, ubyte} to {sbyte, ubyte}
|
|
|
|
// cast {short, ushort} to {ushort, short}
|
|
|
|
// cast {int, uint, ptr} to {int, uint, ptr}
|
|
|
|
//
|
|
|
|
// 3) cast {sbyte, ubyte} to {ushort, short}
|
|
|
|
// cast {sbyte, ubyte} to {int, uint, ptr}
|
|
|
|
// cast {short, ushort} to {int, uint, ptr}
|
|
|
|
//
|
|
|
|
// 4) cast {int, uint, ptr} to {short, ushort}
|
|
|
|
// cast {int, uint, ptr} to {sbyte, ubyte}
|
|
|
|
// cast {short, ushort} to {sbyte, ubyte}
|
|
|
|
//
|
|
|
|
// 1) Implement casts to bool by using compare on the operand followed
|
|
|
|
// by set if not zero on the result.
|
|
|
|
if (targetType == Type::BoolTy)
|
|
|
|
{
|
|
|
|
BuildMI (BB, X86::CMPri8, 2).addReg (operandReg).addZImm (0);
|
|
|
|
BuildMI (BB, X86::SETNEr, 1, destReg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// 2) Implement casts between values of the same type class (as determined
|
|
|
|
// by getClass) by using a register-to-register move.
|
|
|
|
unsigned int srcClass = getClass (sourceType);
|
|
|
|
unsigned int targClass = getClass (targetType);
|
|
|
|
static const unsigned regRegMove[] = {
|
|
|
|
X86::MOVrr8, X86::MOVrr16, X86::MOVrr32
|
|
|
|
};
|
|
|
|
if ((srcClass < 3) && (targClass < 3) && (srcClass == targClass))
|
|
|
|
{
|
|
|
|
BuildMI (BB, regRegMove[srcClass], 1, destReg).addReg (operandReg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// 3) Handle cast of SMALLER int to LARGER int using a move with sign
|
|
|
|
// extension or zero extension, depending on whether the source type
|
|
|
|
// was signed.
|
|
|
|
if ((srcClass < 3) && (targClass < 3) && (srcClass < targClass))
|
|
|
|
{
|
|
|
|
static const unsigned ops[] = {
|
|
|
|
X86::MOVSXr16r8, X86::MOVSXr32r8, X86::MOVSXr32r16,
|
|
|
|
X86::MOVZXr16r8, X86::MOVZXr32r8, X86::MOVZXr32r16
|
|
|
|
};
|
|
|
|
unsigned srcSigned = sourceType->isSigned ();
|
|
|
|
BuildMI (BB, ops[3 * srcSigned + srcClass + targClass - 1], 1,
|
|
|
|
destReg).addReg (operandReg);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// 4) Handle cast of LARGER int to SMALLER int using a move to EAX
|
|
|
|
// followed by a move out of AX or AL.
|
|
|
|
if ((srcClass < 3) && (targClass < 3) && (srcClass > targClass))
|
|
|
|
{
|
|
|
|
static const unsigned AReg[] = { X86::AL, X86::AX, X86::EAX };
|
|
|
|
BuildMI (BB, regRegMove[srcClass], 1,
|
|
|
|
AReg[srcClass]).addReg (operandReg);
|
|
|
|
BuildMI (BB, regRegMove[targClass], 1, destReg).addReg (AReg[srcClass]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// Anything we haven't handled already, we can't (yet) handle at all.
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
//
|
|
|
|
// FP to integral casts can be handled with FISTP to store onto the
|
|
|
|
// stack while converting to integer, followed by a MOV to load from
|
|
|
|
// the stack into the result register. Integral to FP casts can be
|
|
|
|
// handled with MOV to store onto the stack, followed by a FILD to
|
|
|
|
// load from the stack while converting to FP. For the moment, I
|
|
|
|
// can't quite get straight in my head how to borrow myself some
|
|
|
|
// stack space and write on it. Otherwise, this would be trivial.
|
2002-11-22 11:07:01 +00:00
|
|
|
visitInstruction (CI);
|
|
|
|
}
|
2002-10-31 23:03:59 +00:00
|
|
|
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
/// visitGetElementPtrInst - I don't know, most programs don't have
|
|
|
|
/// getelementptr instructions, right? That means we can put off
|
|
|
|
/// implementing this, right? Right. This method emits machine
|
|
|
|
/// instructions to perform type-safe pointer arithmetic. I am
|
|
|
|
/// guessing this could be cleaned up somewhat to use fewer temporary
|
|
|
|
/// registers.
|
|
|
|
void
|
|
|
|
ISel::visitGetElementPtrInst (GetElementPtrInst &I)
|
|
|
|
{
|
|
|
|
Value *basePtr = I.getPointerOperand ();
|
|
|
|
const TargetData &TD = TM.DataLayout;
|
|
|
|
unsigned basePtrReg = getReg (basePtr);
|
|
|
|
unsigned resultReg = getReg (I);
|
|
|
|
const Type *Ty = basePtr->getType();
|
|
|
|
// GEPs have zero or more indices; we must perform a struct access
|
|
|
|
// or array access for each one.
|
|
|
|
for (GetElementPtrInst::op_iterator oi = I.idx_begin (),
|
|
|
|
oe = I.idx_end (); oi != oe; ++oi) {
|
|
|
|
Value *idx = *oi;
|
|
|
|
unsigned nextBasePtrReg = makeAnotherReg ();
|
|
|
|
if (const StructType *StTy = dyn_cast <StructType> (Ty)) {
|
|
|
|
// It's a struct access. idx is the index into the structure,
|
|
|
|
// which names the field. This index must have ubyte type.
|
|
|
|
const ConstantUInt *CUI = cast <ConstantUInt> (idx);
|
|
|
|
assert (CUI->getType () == Type::UByteTy
|
|
|
|
&& "Funny-looking structure index in GEP");
|
|
|
|
// Use the TargetData structure to pick out what the layout of
|
|
|
|
// the structure is in memory. Since the structure index must
|
|
|
|
// be constant, we can get its value and use it to find the
|
|
|
|
// right byte offset from the StructLayout class's list of
|
|
|
|
// structure member offsets.
|
|
|
|
unsigned idxValue = CUI->getValue ();
|
|
|
|
unsigned memberOffset =
|
|
|
|
TD.getStructLayout (StTy)->MemberOffsets[idxValue];
|
|
|
|
// Emit an ADD to add memberOffset to the basePtr.
|
|
|
|
BuildMI (BB, X86::ADDri32, 2,
|
|
|
|
nextBasePtrReg).addReg (basePtrReg).addZImm (memberOffset);
|
|
|
|
// The next type is the member of the structure selected by the
|
|
|
|
// index.
|
|
|
|
Ty = StTy->getElementTypes ()[idxValue];
|
|
|
|
} else if (const SequentialType *SqTy = cast <SequentialType> (Ty)) {
|
|
|
|
// It's an array or pointer access: [ArraySize x ElementType].
|
|
|
|
// The documentation does not seem to match the code on the type
|
|
|
|
// of array indices. The code seems to use long, and the docs
|
|
|
|
// (and the comments) say uint. If it is long, I don't know what
|
|
|
|
// we are going to do, because the X86 loves 64-bit types.
|
|
|
|
const Type *typeOfSequentialTypeIndex = SqTy->getIndexType ();
|
|
|
|
// idx is the index into the array. Unlike with structure
|
|
|
|
// indices, we may not know its actual value at code-generation
|
|
|
|
// time.
|
|
|
|
assert (idx->getType () == typeOfSequentialTypeIndex
|
|
|
|
&& "Funny-looking array index in GEP");
|
|
|
|
// We want to add basePtrReg to (idxReg * sizeof
|
|
|
|
// ElementType). First, we must find the size of the pointed-to
|
|
|
|
// type. (Not coincidentally, the next type is the type of the
|
|
|
|
// elements in the array.)
|
|
|
|
Ty = SqTy->getElementType ();
|
|
|
|
unsigned elementSize = TD.getTypeSize (Ty);
|
|
|
|
unsigned elementSizeReg = makeAnotherReg ();
|
|
|
|
copyConstantToRegister (ConstantInt::get (typeOfSequentialTypeIndex,
|
|
|
|
elementSize),
|
|
|
|
elementSizeReg);
|
|
|
|
unsigned idxReg = getReg (idx);
|
|
|
|
// Emit a MUL to multiply the register holding the index by
|
|
|
|
// elementSize, putting the result in memberOffsetReg.
|
|
|
|
unsigned memberOffsetReg = makeAnotherReg ();
|
|
|
|
doMultiply (memberOffsetReg, typeOfSequentialTypeIndex,
|
|
|
|
elementSizeReg, idxReg);
|
|
|
|
// Emit an ADD to add memberOffsetReg to the basePtr.
|
|
|
|
BuildMI (BB, X86::ADDrr32, 2,
|
|
|
|
nextBasePtrReg).addReg (basePtrReg).addReg (memberOffsetReg);
|
|
|
|
}
|
|
|
|
// Now that we are here, further indices refer to subtypes of this
|
|
|
|
// one, so we don't need to worry about basePtrReg itself, anymore.
|
|
|
|
basePtrReg = nextBasePtrReg;
|
|
|
|
}
|
|
|
|
// After we have processed all the indices, the result is left in
|
|
|
|
// basePtrReg. Move it to the register where we were expected to
|
|
|
|
// put the answer. A 32-bit move should do it, because we are in
|
|
|
|
// ILP32 land.
|
|
|
|
BuildMI (BB, X86::MOVrr32, 1, getReg (I)).addReg (basePtrReg);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// visitMallocInst - I know that personally, whenever I want to remember
|
|
|
|
/// something, I have to clear off some space in my brain.
|
|
|
|
void
|
|
|
|
ISel::visitMallocInst (MallocInst &I)
|
|
|
|
{
|
2002-12-13 06:46:31 +00:00
|
|
|
// We assume that by this point, malloc instructions have been
|
|
|
|
// lowered to calls, and dlsym will magically find malloc for us.
|
|
|
|
// So we do not want to see malloc instructions here.
|
|
|
|
visitInstruction (I);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// visitFreeInst - same story as MallocInst
|
|
|
|
void
|
|
|
|
ISel::visitFreeInst (FreeInst &I)
|
|
|
|
{
|
|
|
|
// We assume that by this point, free instructions have been
|
|
|
|
// lowered to calls, and dlsym will magically find free for us.
|
|
|
|
// So we do not want to see free instructions here.
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
visitInstruction (I);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// visitAllocaInst - I want some stack space. Come on, man, I said I
|
|
|
|
/// want some freakin' stack space.
|
|
|
|
void
|
|
|
|
ISel::visitAllocaInst (AllocaInst &I)
|
|
|
|
{
|
2002-12-13 06:46:31 +00:00
|
|
|
// Find the data size of the alloca inst's getAllocatedType.
|
|
|
|
const Type *allocatedType = I.getAllocatedType ();
|
|
|
|
const TargetData &TD = TM.DataLayout;
|
|
|
|
unsigned allocatedTypeSize = TD.getTypeSize (allocatedType);
|
|
|
|
// Keep stack 32-bit aligned.
|
|
|
|
unsigned int allocatedTypeWords = allocatedTypeSize / 4;
|
|
|
|
if (allocatedTypeSize % 4 != 0) { allocatedTypeWords++; }
|
|
|
|
// Subtract size from stack pointer, thereby allocating some space.
|
|
|
|
BuildMI (BB, X86::SUBri32, 1, X86::ESP).addZImm (allocatedTypeWords * 4);
|
|
|
|
// Put a pointer to the space into the result register, by copying
|
|
|
|
// the stack pointer.
|
|
|
|
BuildMI (BB, X86::MOVrr32, 1, getReg (I)).addReg (X86::ESP);
|
This checkin is brought to you by the brian gaeke allnighter fund.
(lib/Target/X86) InstSelectSimple.cpp:
Include llvm/DerivedTypes.h and iostream.
Refactor visitMul out into a wrapper around doMultiply(), so that we
can do multiplications on temporary values when we are doing
getelementptrs.
Refactor part of getReg out into makeAnotherReg, so that we can create
registers willy-nilly to hold temporary values, when we are doing
getelementptrs.
Add stub implementations of visitMallocInst and visitAllocaInst.
Add initial implementation of visitGetElementPtrInst.
In copyConstantToRegister:
We throw a *lot* of our asserts here. So, when we want to throw an
assert, print out to stderr whatever expr or whatever constant made
us barf.
Support copying ConstantPointerNull to register, using a move immediate
of zero.
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
Teach visitCallInst to extract byte- and short-class return values
from subregs of EAX. Add a FIXME note about how we would do it for
float-class return values.
Add a FIXME note about how we would cast float to int and back.
X86InstrInfo.def:
Rename FLDr4 and FLDr8 to FLDr32 and FLDr64, so that they match the meanings
of the numbers in the other instruction names. All uses modified.
(tools/jello) GlobalVars.cpp:
Include iostream.
If we have to emit a floating-point constant to memory, gamble and use
the same method as for ints.
If we have to emit a ConstantPointerNull to memory, try using a "void *"
and "NULL".
Otherwise, if we are going to throw an assert, print out whatever constant
made us barf, first.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4973 91177308-0d34-0410-b5e6-96231b3b80d8
2002-12-12 15:33:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-10-29 22:37:54 +00:00
|
|
|
/// createSimpleX86InstructionSelector - This pass converts an LLVM function
|
|
|
|
/// into a machine code representation is a very simple peep-hole fashion. The
|
2002-10-25 22:55:53 +00:00
|
|
|
/// generated code sucks but the implementation is nice and simple.
|
|
|
|
///
|
2002-10-29 22:37:54 +00:00
|
|
|
Pass *createSimpleX86InstructionSelector(TargetMachine &TM) {
|
|
|
|
return new ISel(TM);
|
2002-10-25 22:55:53 +00:00
|
|
|
}
|