//===-- InstSelectSimple.cpp - A simple instruction selector for SparcV8 --===//
-//
+//
// 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 defines a simple peephole instruction selector for the V8 target
#include "llvm/Instructions.h"
#include "llvm/Pass.h"
#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/CodeGen/IntrinsicLowering.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/SSARegMap.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/CFG.h"
using namespace llvm;
unsigned emitIntegerCast (MachineBasicBlock *BB,
MachineBasicBlock::iterator IP,
const Type *oldTy, unsigned SrcReg,
- const Type *newTy, unsigned DestReg);
+ const Type *newTy, unsigned DestReg,
+ bool castToLong = false);
void emitFPToIntegerCast (MachineBasicBlock *BB,
MachineBasicBlock::iterator IP, const Type *oldTy,
unsigned SrcReg, const Type *newTy,
void visitBranchInst(BranchInst &I);
void visitUnreachableInst(UnreachableInst &I) {}
void visitCastInst(CastInst &I);
- void visitVANextInst(VANextInst &I);
void visitVAArgInst(VAArgInst &I);
void visitLoadInst(LoadInst &I);
void visitStoreInst(StoreInst &I);
abort();
}
} else if (isa<UndefValue>(C)) {
- BuildMI(*MBB, IP, V8::IMPLICIT_DEF, 0, R);
+ BuildMI(*MBB, IP, V8::IMPLICIT_DEF_Int, 0, R);
if (getClassB (C->getType ()) == cLong)
- BuildMI(*MBB, IP, V8::IMPLICIT_DEF, 0, R+1);
+ BuildMI(*MBB, IP, V8::IMPLICIT_DEF_Int, 0, R+1);
return;
}
if (C->getType()->isIntegral ()) {
- uint64_t Val;
unsigned Class = getClassB (C->getType ());
if (Class == cLong) {
unsigned TmpReg = makeAnotherReg (Type::IntTy);
}
assert(Class <= cInt && "Type not handled yet!");
+ unsigned Val;
if (C->getType() == Type::BoolTy) {
Val = (C == ConstantBool::True);
} else {
- ConstantInt *CI = cast<ConstantInt> (C);
- Val = CI->getRawValue ();
+ ConstantIntegral *CI = cast<ConstantIntegral> (C);
+ Val = CI->getRawValue();
}
- switch (Class) {
- case cByte: Val = (int8_t) Val; break;
- case cShort: Val = (int16_t) Val; break;
- case cInt: Val = (int32_t) Val; break;
- default:
- std::cerr << "Offending constant: " << *C << "\n";
- assert (0 && "Can't copy this kind of constant into register yet");
- return;
+ if (C->getType()->isSigned()) {
+ switch (Class) {
+ case cByte: Val = (int8_t) Val; break;
+ case cShort: Val = (int16_t) Val; break;
+ case cInt: Val = (int32_t) Val; break;
+ }
+ } else {
+ switch (Class) {
+ case cByte: Val = (uint8_t) Val; break;
+ case cShort: Val = (uint16_t) Val; break;
+ case cInt: Val = (uint32_t) Val; break;
+ }
}
if (Val == 0) {
BuildMI (*MBB, IP, V8::ORrr, 2, R).addReg (V8::G0).addReg(V8::G0);
- } else if (((int64_t)Val >= -4096) && ((int64_t)Val <= 4095)) {
+ } else if ((int)Val >= -4096 && (int)Val <= 4095) {
BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (V8::G0).addSImm(Val);
} else {
unsigned TmpReg = makeAnotherReg (C->getType ());
BuildMI (*MBB, IP, V8::ORri, 2, R).addReg (V8::G0).addSImm (0);
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(C)) {
// Copy it with a SETHI/OR pair; the JIT + asmwriter should recognize
- // that SETHI %reg,global == SETHI %reg,%hi(global) and
+ // that SETHI %reg,global == SETHI %reg,%hi(global) and
// OR %reg,global,%reg == OR %reg,%lo(global),%reg.
unsigned TmpReg = makeAnotherReg (C->getType ());
BuildMI (*MBB, IP, V8::SETHIi, 1, TmpReg).addGlobalAddress(GV);
// Add IMPLICIT_DEFs of input regs.
unsigned ArgNo = 0;
- for (Function::aiterator I = LF->abegin(), E = LF->aend();
+ for (Function::arg_iterator I = LF->arg_begin(), E = LF->arg_end();
I != E && ArgNo < 6; ++I, ++ArgNo) {
switch (getClassB(I->getType())) {
case cByte:
case cShort:
case cInt:
case cFloat:
- BuildMI(BB, V8::IMPLICIT_DEF, 0, IncomingArgRegs[ArgNo]);
+ BuildMI(BB, V8::IMPLICIT_DEF_Int, 0, IncomingArgRegs[ArgNo]);
break;
case cDouble:
case cLong:
// Double and Long use register pairs.
- BuildMI(BB, V8::IMPLICIT_DEF, 0, IncomingArgRegs[ArgNo]);
+ BuildMI(BB, V8::IMPLICIT_DEF_Int, 0, IncomingArgRegs[ArgNo]);
++ArgNo;
if (ArgNo < 6)
- BuildMI(BB, V8::IMPLICIT_DEF, 0, IncomingArgRegs[ArgNo]);
+ BuildMI(BB, V8::IMPLICIT_DEF_Int, 0, IncomingArgRegs[ArgNo]);
break;
default:
assert (0 && "type not handled");
const unsigned *IAR = &IncomingArgRegs[0];
unsigned ArgOffset = 68;
- // Store registers onto stack if this is a varargs function.
+ // Store registers onto stack if this is a varargs function.
// FIXME: This doesn't really pertain to "loading arguments into
// virtual registers", so it's not clear that it really belongs here.
- // FIXME: We could avoid storing any args onto the stack that don't
+ // FIXME: We could avoid storing any args onto the stack that don't
// need to be in memory, because they come before the ellipsis in the
// parameter list (and thus could never be accessed through va_arg).
- if (LF->getFunctionType ()->isVarArg ()) {
+ if (LF->getFunctionType()->isVarArg()) {
for (unsigned i = 0; i < 6; ++i) {
int FI = F->getFrameInfo()->CreateFixedObject(4, ArgOffset);
assert (IAR != IAREnd
&& "About to dereference past end of IncomingArgRegs");
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (0).addReg (*IAR++);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (0).addReg (*IAR++);
ArgOffset += 4;
}
// Reset the pointers now that we're done.
}
// Copy args out of their incoming hard regs or stack slots into virtual regs.
- for (Function::aiterator I = LF->abegin(), E = LF->aend(); I != E; ++I) {
+ for (Function::arg_iterator I = LF->arg_begin(), E = LF->arg_end(); I != E; ++I) {
Argument &A = *I;
unsigned ArgReg = getReg (A);
if (getClassB (A.getType ()) < cLong) {
BuildMI (BB, V8::ORrr, 2, ArgReg).addReg (V8::G0).addReg (*IAR++);
} else {
int FI = F->getFrameInfo()->CreateFixedObject(4, ArgOffset);
- BuildMI (BB, V8::LD, 3, ArgReg).addFrameIndex (FI).addSImm (0);
+ BuildMI (BB, V8::LDri, 3, ArgReg).addFrameIndex (FI).addSImm (0);
}
ArgOffset += 4;
} else if (getClassB (A.getType ()) == cFloat) {
int FI = F->getFrameInfo()->CreateStackObject(4, FltAlign);
assert (IAR != IAREnd
&& "About to dereference past end of IncomingArgRegs");
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (0).addReg (*IAR++);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (0).addReg (*IAR++);
BuildMI (BB, V8::LDFri, 2, ArgReg).addFrameIndex (FI).addSImm (0);
} else {
int FI = F->getFrameInfo()->CreateFixedObject(4, ArgOffset);
unsigned DblAlign = TM.getTargetData().getDoubleAlignment();
int FI = F->getFrameInfo()->CreateStackObject(8, DblAlign);
if (ArgOffset < 92 && IAR != IAREnd) {
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (0).addReg (*IAR++);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (0).addReg (*IAR++);
} else {
unsigned TempReg = makeAnotherReg (Type::IntTy);
- BuildMI (BB, V8::LD, 2, TempReg).addFrameIndex (FI).addSImm (0);
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (0).addReg (TempReg);
+ BuildMI (BB, V8::LDri, 2, TempReg).addFrameIndex (FI).addSImm (0);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (0).addReg (TempReg);
}
ArgOffset += 4;
if (ArgOffset < 92 && IAR != IAREnd) {
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (4).addReg (*IAR++);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (4).addReg (*IAR++);
} else {
unsigned TempReg = makeAnotherReg (Type::IntTy);
- BuildMI (BB, V8::LD, 2, TempReg).addFrameIndex (FI).addSImm (4);
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (4).addReg (TempReg);
+ BuildMI (BB, V8::LDri, 2, TempReg).addFrameIndex (FI).addSImm (4);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (4).addReg (TempReg);
}
ArgOffset += 4;
BuildMI (BB, V8::LDDFri, 2, ArgReg).addFrameIndex (FI).addSImm (0);
BuildMI (BB, V8::ORrr, 2, ArgReg).addReg (V8::G0).addReg (*IAR++);
} else {
int FI = F->getFrameInfo()->CreateFixedObject(4, ArgOffset);
- BuildMI (BB, V8::LD, 2, ArgReg).addFrameIndex (FI).addSImm (0);
+ BuildMI (BB, V8::LDri, 2, ArgReg).addFrameIndex (FI).addSImm (0);
}
ArgOffset += 4;
// ...then do the second half
BuildMI (BB, V8::ORrr, 2, ArgReg+1).addReg (V8::G0).addReg (*IAR++);
} else {
int FI = F->getFrameInfo()->CreateFixedObject(4, ArgOffset);
- BuildMI (BB, V8::LD, 2, ArgReg+1).addFrameIndex (FI).addSImm (0);
+ BuildMI (BB, V8::LDri, 2, ArgReg+1).addFrameIndex (FI).addSImm (0);
}
ArgOffset += 4;
} else {
break;
}
assert (PredMBB && "Couldn't find incoming machine-cfg edge for phi");
-
+
unsigned ValReg;
std::map<MachineBasicBlock*, unsigned>::iterator EntryIt =
PHIValues.lower_bound(PredMBB);
// predecessor. Recycle it.
ValReg = EntryIt->second;
- } else {
+ } else {
// Get the incoming value into a virtual register.
//
Value *Val = PN->getIncomingValue(i);
// might be arbitrarily complex if it is a constant expression),
// just insert the computation at the top of the basic block.
MachineBasicBlock::iterator PI = PredMBB->begin();
-
+
// Skip over any PHI nodes though!
while (PI != PredMBB->end() && PI->getOpcode() == V8::PHI)
++PI;
-
+
ValReg = getReg(Val, PredMBB, PI);
}
// First pass over the function, lower any unknown intrinsic functions
// with the IntrinsicLowering class.
LowerUnknownIntrinsicFunctionCalls(Fn);
-
+
F = &MachineFunction::construct(&Fn, TM);
-
+
// Create all of the machine basic blocks for the function...
for (Function::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I)
F->getBasicBlockList().push_back(MBBMap[I] = new MachineBasicBlock(I));
-
+
BB = &F->front();
-
+
// Set up a frame object for the return address. This is used by the
// llvm.returnaddress & llvm.frameaddress intrinisics.
//ReturnAddressIndex = F->getFrameInfo()->CreateFixedObject(4, -4);
-
+
// Copy incoming arguments off of the stack and out of fixed registers.
LoadArgumentsToVirtualRegs(&Fn);
-
+
// Instruction select everything except PHI nodes
visit(Fn);
-
+
// Select the PHI nodes
SelectPHINodes();
-
+
RegMap.clear();
MBBMap.clear();
F = 0;
unsigned V8ISel::emitIntegerCast (MachineBasicBlock *BB,
MachineBasicBlock::iterator IP, const Type *oldTy,
unsigned SrcReg, const Type *newTy,
- unsigned DestReg) {
- if (oldTy == newTy) {
+ unsigned DestReg, bool castToLong) {
+ unsigned shiftWidth = 32 - (8 * TM.getTargetData ().getTypeSize (newTy));
+ if (oldTy == newTy || (!castToLong && shiftWidth == 0)) {
// No-op cast - just emit a copy; assume the reg. allocator will zap it.
BuildMI (*BB, IP, V8::ORrr, 2, DestReg).addReg (V8::G0).addReg(SrcReg);
return SrcReg;
}
// Emit left-shift, then right-shift to sign- or zero-extend.
unsigned TmpReg = makeAnotherReg (newTy);
- unsigned shiftWidth = 32 - (8 * TM.getTargetData ().getTypeSize (newTy));
BuildMI (*BB, IP, V8::SLLri, 2, TmpReg).addZImm (shiftWidth).addReg(SrcReg);
if (newTy->isSigned ()) { // sign-extend with SRA
BuildMI(*BB, IP, V8::SRAri, 2, DestReg).addZImm (shiftWidth).addReg(TmpReg);
const Type *newTy, unsigned DestReg) {
unsigned FPCastOpcode, FPStoreOpcode, FPSize, FPAlign;
unsigned oldTyClass = getClassB(oldTy);
- if (oldTyClass == cFloat) {
- FPCastOpcode = V8::FSTOI; FPStoreOpcode = V8::STFri; FPSize = 4;
+ if (oldTyClass == cFloat) {
+ FPCastOpcode = V8::FSTOI; FPStoreOpcode = V8::STFri; FPSize = 4;
FPAlign = TM.getTargetData().getFloatAlignment();
} else { // it's a double
- FPCastOpcode = V8::FDTOI; FPStoreOpcode = V8::STDFri; FPSize = 8;
+ FPCastOpcode = V8::FDTOI; FPStoreOpcode = V8::STDFri; FPSize = 8;
FPAlign = TM.getTargetData().getDoubleAlignment();
}
unsigned TempReg = makeAnotherReg (oldTy);
BuildMI (*BB, IP, FPStoreOpcode, 3).addFrameIndex (FI).addSImm (0)
.addReg (TempReg);
unsigned TempReg2 = makeAnotherReg (newTy);
- BuildMI (*BB, IP, V8::LD, 3, TempReg2).addFrameIndex (FI).addSImm (0);
+ BuildMI (*BB, IP, V8::LDri, 3, TempReg2).addFrameIndex (FI).addSImm (0);
emitIntegerCast (BB, IP, Type::IntTy, TempReg2, newTy, DestReg);
}
case cShort:
case cInt:
switch (oldTyClass) {
- case cLong:
+ case cLong:
// Treat it like a cast from the lower half of the value.
emitIntegerCast (BB, IP, Type::IntTy, SrcReg+1, newTy, DestReg);
break;
- case cFloat:
+ case cFloat:
case cDouble:
emitFPToIntegerCast (BB, IP, oldTy, SrcReg, newTy, DestReg);
break;
// it using ldf into a floating point register. then do fitos.
unsigned TmpReg = makeAnotherReg (newTy);
int FI = F->getFrameInfo()->CreateStackObject(4, FltAlign);
- BuildMI (*BB, IP, V8::ST, 3).addFrameIndex (FI).addSImm (0)
+ BuildMI (*BB, IP, V8::STri, 3).addFrameIndex (FI).addSImm (0)
.addReg (SrcReg);
BuildMI (*BB, IP, V8::LDFri, 2, TmpReg).addFrameIndex (FI).addSImm (0);
BuildMI (*BB, IP, V8::FITOS, 1, DestReg).addReg(TmpReg);
unsigned DoubleAlignment = TM.getTargetData().getDoubleAlignment();
unsigned TmpReg = makeAnotherReg (newTy);
int FI = F->getFrameInfo()->CreateStackObject(8, DoubleAlignment);
- BuildMI (*BB, IP, V8::ST, 3).addFrameIndex (FI).addSImm (0)
+ BuildMI (*BB, IP, V8::STri, 3).addFrameIndex (FI).addSImm (0)
.addReg (SrcReg);
BuildMI (*BB, IP, V8::LDDFri, 2, TmpReg).addFrameIndex (FI).addSImm (0);
BuildMI (*BB, IP, V8::FITOD, 1, DestReg).addReg(TmpReg);
const Type *OldHalfTy = oldTy->isSigned() ? Type::IntTy : Type::UIntTy;
const Type *NewHalfTy = newTy->isSigned() ? Type::IntTy : Type::UIntTy;
unsigned TempReg = emitIntegerCast (BB, IP, OldHalfTy, SrcReg,
- NewHalfTy, DestReg+1);
+ NewHalfTy, DestReg+1, true);
if (newTy->isSigned ()) {
- BuildMI (*BB, IP, V8::SRAri, 2, DestReg).addReg (TempReg)
+ BuildMI (*BB, IP, V8::SRAri, 2, DestReg).addReg (TempReg)
.addZImm (31);
} else {
- BuildMI (*BB, IP, V8::ORrr, 2, DestReg).addReg (V8::G0)
+ BuildMI (*BB, IP, V8::ORrr, 2, DestReg).addReg (V8::G0)
.addReg (V8::G0);
}
break;
switch (getClassB (I.getType ())) {
case cByte:
if (I.getType ()->isSigned ())
- BuildMI (BB, V8::LDSB, 2, DestReg).addReg (PtrReg).addSImm(0);
+ BuildMI (BB, V8::LDSBri, 2, DestReg).addReg (PtrReg).addSImm(0);
else
- BuildMI (BB, V8::LDUB, 2, DestReg).addReg (PtrReg).addSImm(0);
+ BuildMI (BB, V8::LDUBri, 2, DestReg).addReg (PtrReg).addSImm(0);
return;
case cShort:
if (I.getType ()->isSigned ())
- BuildMI (BB, V8::LDSH, 2, DestReg).addReg (PtrReg).addSImm(0);
+ BuildMI (BB, V8::LDSHri, 2, DestReg).addReg (PtrReg).addSImm(0);
else
- BuildMI (BB, V8::LDUH, 2, DestReg).addReg (PtrReg).addSImm(0);
+ BuildMI (BB, V8::LDUHri, 2, DestReg).addReg (PtrReg).addSImm(0);
return;
case cInt:
- BuildMI (BB, V8::LD, 2, DestReg).addReg (PtrReg).addSImm(0);
+ BuildMI (BB, V8::LDri, 2, DestReg).addReg (PtrReg).addSImm(0);
return;
case cLong:
- BuildMI (BB, V8::LD, 2, DestReg).addReg (PtrReg).addSImm(0);
- BuildMI (BB, V8::LD, 2, DestReg+1).addReg (PtrReg).addSImm(4);
+ BuildMI (BB, V8::LDri, 2, DestReg).addReg (PtrReg).addSImm(0);
+ BuildMI (BB, V8::LDri, 2, DestReg+1).addReg (PtrReg).addSImm(4);
return;
case cFloat:
BuildMI (BB, V8::LDFri, 2, DestReg).addReg (PtrReg).addSImm(0);
unsigned PtrReg = getReg (I.getOperand (1));
switch (getClassB (SrcVal->getType ())) {
case cByte:
- BuildMI (BB, V8::STB, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
+ BuildMI (BB, V8::STBri, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
return;
case cShort:
- BuildMI (BB, V8::STH, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
+ BuildMI (BB, V8::STHri, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
return;
case cInt:
- BuildMI (BB, V8::ST, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
+ BuildMI (BB, V8::STri, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
return;
case cLong:
- BuildMI (BB, V8::ST, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
- BuildMI (BB, V8::ST, 3).addReg (PtrReg).addSImm (4).addReg (SrcReg+1);
+ BuildMI (BB, V8::STri, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
+ BuildMI (BB, V8::STri, 3).addReg (PtrReg).addSImm (4).addReg (SrcReg+1);
return;
case cFloat:
BuildMI (BB, V8::STFri, 3).addReg (PtrReg).addSImm (0).addReg (SrcReg);
if (getClassB (I.getOperand (i)->getType ()) < cLong) {
// Schlep it over into the incoming arg register
if (ArgOffset < 92) {
- assert (OAR != OAREnd && "About to dereference past end of OutgoingArgRegs");
- BuildMI (BB, V8::ORrr, 2, *OAR++).addReg (V8::G0).addReg (ArgReg);
+ assert (OAR != OAREnd &&
+ "About to dereference past end of OutgoingArgRegs");
+ BuildMI (BB, V8::ORrr, 2, *OAR++).addReg (V8::G0).addReg (ArgReg);
} else {
- BuildMI (BB, V8::ST, 3).addReg (V8::SP).addSImm (ArgOffset).addReg (ArgReg);
+ BuildMI (BB, V8::STri, 3).addReg (V8::O6).addSImm (ArgOffset)
+ .addReg (ArgReg);
}
ArgOffset += 4;
} else if (getClassB (I.getOperand (i)->getType ()) == cFloat) {
if (ArgOffset < 92) {
- // Single-fp args are passed in integer registers; go through
- // memory to get them out of FP registers. (Bleh!)
- unsigned FltAlign = TM.getTargetData().getFloatAlignment();
- int FI = F->getFrameInfo()->CreateStackObject(4, FltAlign);
- BuildMI (BB, V8::STFri, 3).addFrameIndex (FI).addSImm (0).addReg (ArgReg);
- assert (OAR != OAREnd && "About to dereference past end of OutgoingArgRegs");
- BuildMI (BB, V8::LD, 2, *OAR++).addFrameIndex (FI).addSImm (0);
+ // Single-fp args are passed in integer registers; go through
+ // memory to get them out of FP registers. (Bleh!)
+ unsigned FltAlign = TM.getTargetData().getFloatAlignment();
+ int FI = F->getFrameInfo()->CreateStackObject(4, FltAlign);
+ BuildMI (BB, V8::STFri, 3).addFrameIndex(FI).addSImm(0).addReg(ArgReg);
+ assert (OAR != OAREnd &&
+ "About to dereference past end of OutgoingArgRegs");
+ BuildMI (BB, V8::LDri, 2, *OAR++).addFrameIndex (FI).addSImm (0);
} else {
- BuildMI (BB, V8::STFri, 3).addReg (V8::SP).addSImm (ArgOffset).addReg (ArgReg);
+ BuildMI (BB, V8::STFri, 3).addReg (V8::O6).addSImm (ArgOffset)
+ .addReg (ArgReg);
}
ArgOffset += 4;
} else if (getClassB (I.getOperand (i)->getType ()) == cDouble) {
int FI = F->getFrameInfo()->CreateStackObject(8, DblAlign);
BuildMI (BB, V8::STDFri, 3).addFrameIndex (FI).addSImm (0).addReg (ArgReg);
if (ArgOffset < 92 && OAR != OAREnd) {
- assert (OAR != OAREnd && "About to dereference past end of OutgoingArgRegs");
- BuildMI (BB, V8::LD, 2, *OAR++).addFrameIndex (FI).addSImm (0);
+ assert (OAR != OAREnd &&
+ "About to dereference past end of OutgoingArgRegs");
+ BuildMI (BB, V8::LDri, 2, *OAR++).addFrameIndex (FI).addSImm (0);
} else {
unsigned TempReg = makeAnotherReg (Type::IntTy);
- BuildMI (BB, V8::LD, 2, TempReg).addFrameIndex (FI).addSImm (0);
- BuildMI (BB, V8::ST, 3).addReg (V8::SP).addSImm (ArgOffset).addReg (TempReg);
+ BuildMI (BB, V8::LDri, 2, TempReg).addFrameIndex (FI).addSImm (0);
+ BuildMI (BB, V8::STri, 3).addReg (V8::O6).addSImm (ArgOffset)
+ .addReg (TempReg);
}
ArgOffset += 4;
if (ArgOffset < 92 && OAR != OAREnd) {
- assert (OAR != OAREnd && "About to dereference past end of OutgoingArgRegs");
- BuildMI (BB, V8::LD, 2, *OAR++).addFrameIndex (FI).addSImm (4);
+ assert (OAR != OAREnd &&
+ "About to dereference past end of OutgoingArgRegs");
+ BuildMI (BB, V8::LDri, 2, *OAR++).addFrameIndex (FI).addSImm (4);
} else {
unsigned TempReg = makeAnotherReg (Type::IntTy);
- BuildMI (BB, V8::LD, 2, TempReg).addFrameIndex (FI).addSImm (4);
- BuildMI (BB, V8::ST, 3).addReg (V8::SP).addSImm (ArgOffset).addReg (TempReg);
+ BuildMI (BB, V8::LDri, 2, TempReg).addFrameIndex (FI).addSImm (4);
+ BuildMI (BB, V8::STri, 3).addReg (V8::O6).addSImm (ArgOffset)
+ .addReg (TempReg);
}
ArgOffset += 4;
} else if (getClassB (I.getOperand (i)->getType ()) == cLong) {
// do the first half...
if (ArgOffset < 92) {
- assert (OAR != OAREnd && "About to dereference past end of OutgoingArgRegs");
- BuildMI (BB, V8::ORrr, 2, *OAR++).addReg (V8::G0).addReg (ArgReg);
+ assert (OAR != OAREnd &&
+ "About to dereference past end of OutgoingArgRegs");
+ BuildMI (BB, V8::ORrr, 2, *OAR++).addReg (V8::G0).addReg (ArgReg);
} else {
- BuildMI (BB, V8::ST, 3).addReg (V8::SP).addSImm (ArgOffset).addReg (ArgReg);
+ BuildMI (BB, V8::STri, 3).addReg (V8::O6).addSImm (ArgOffset)
+ .addReg (ArgReg);
}
ArgOffset += 4;
// ...then do the second half
if (ArgOffset < 92) {
- assert (OAR != OAREnd && "About to dereference past end of OutgoingArgRegs");
- BuildMI (BB, V8::ORrr, 2, *OAR++).addReg (V8::G0).addReg (ArgReg+1);
+ assert (OAR != OAREnd &&
+ "About to dereference past end of OutgoingArgRegs");
+ BuildMI (BB, V8::ORrr, 2, *OAR++).addReg (V8::G0).addReg (ArgReg+1);
} else {
- BuildMI (BB, V8::ST, 3).addReg (V8::SP).addSImm (ArgOffset).addReg (ArgReg+1);
+ BuildMI (BB, V8::STri, 3).addReg (V8::O6).addSImm (ArgOffset)
+ .addReg (ArgReg+1);
}
ArgOffset += 4;
} else {
return I != BB->getParent()->end() ? &*I : 0;
}
+/// canFoldSetCCIntoBranch - Return the setcc instruction if we can fold it
+/// into the conditional branch which is the only user of the cc instruction.
+/// This is the case if the conditional branch is the only user of the setcc.
+///
+static SetCondInst *canFoldSetCCIntoBranch(Value *V) {
+ //return 0; // disable.
+ if (SetCondInst *SCI = dyn_cast<SetCondInst>(V))
+ if (SCI->hasOneUse()) {
+ BranchInst *User = dyn_cast<BranchInst>(SCI->use_back());
+ if (User
+ && (SCI->getNext() == User)
+ && (getClassB(SCI->getOperand(0)->getType()) != cLong)
+ && User->isConditional() && (User->getCondition() == V))
+ return SCI;
+ }
+ return 0;
+}
+
/// visitBranchInst - Handles conditional and unconditional branches.
///
void V8ISel::visitBranchInst(BranchInst &I) {
MachineBasicBlock *notTakenSuccMBB = MBBMap[notTakenSucc];
BB->addSuccessor (notTakenSuccMBB);
- // CondReg=(<condition>);
- // If (CondReg==0) goto notTakenSuccMBB;
- unsigned CondReg = getReg (I.getCondition ());
- BuildMI (BB, V8::CMPri, 2).addSImm (0).addReg (CondReg);
- BuildMI (BB, V8::BE, 1).addMBB (notTakenSuccMBB);
+ // See if we can fold a previous setcc instr into this branch.
+ SetCondInst *SCI = canFoldSetCCIntoBranch(I.getCondition());
+ if (SCI == 0) {
+ // The condition did not come from a setcc which we could fold.
+ // CondReg=(<condition>);
+ // If (CondReg==0) goto notTakenSuccMBB;
+ unsigned CondReg = getReg (I.getCondition ());
+ BuildMI (BB, V8::SUBCCri, 2, V8::G0).addReg(CondReg).addSImm(0);
+ BuildMI (BB, V8::BE, 1).addMBB (notTakenSuccMBB);
+ BuildMI (BB, V8::BA, 1).addMBB (takenSuccMBB);
+ return;
+ }
+
+ // Fold the setCC instr into the branch.
+ unsigned Op0Reg = getReg (SCI->getOperand (0));
+ unsigned Op1Reg = getReg (SCI->getOperand (1));
+ const Type *Ty = SCI->getOperand (0)->getType ();
+
+ // Compare the two values.
+ if (getClass (Ty) < cLong) {
+ BuildMI(BB, V8::SUBCCrr, 2, V8::G0).addReg(Op0Reg).addReg(Op1Reg);
+ } else if (getClass (Ty) == cLong) {
+ assert (0 && "Can't fold setcc long/ulong into branch");
+ } else if (getClass (Ty) == cFloat) {
+ BuildMI(BB, V8::FCMPS, 2).addReg(Op0Reg).addReg(Op1Reg);
+ } else if (getClass (Ty) == cDouble) {
+ BuildMI(BB, V8::FCMPD, 2).addReg(Op0Reg).addReg(Op1Reg);
+ }
+
+ unsigned BranchIdx;
+ switch (SCI->getOpcode()) {
+ default: assert(0 && "Unknown setcc instruction!");
+ case Instruction::SetEQ: BranchIdx = 0; break;
+ case Instruction::SetNE: BranchIdx = 1; break;
+ case Instruction::SetLT: BranchIdx = 2; break;
+ case Instruction::SetGT: BranchIdx = 3; break;
+ case Instruction::SetLE: BranchIdx = 4; break;
+ case Instruction::SetGE: BranchIdx = 5; break;
+ }
+
+ unsigned Column = 0;
+ if (Ty->isSigned() && !Ty->isFloatingPoint()) Column = 1;
+ if (Ty->isFloatingPoint()) Column = 2;
+ static unsigned OpcodeTab[3*6] = {
+ // LLVM SparcV8
+ // unsigned signed fp
+ V8::BE, V8::BE, V8::FBE, // seteq = be be fbe
+ V8::BNE, V8::BNE, V8::FBNE, // setne = bne bne fbne
+ V8::BCS, V8::BL, V8::FBL, // setlt = bcs bl fbl
+ V8::BGU, V8::BG, V8::FBG, // setgt = bgu bg fbg
+ V8::BLEU, V8::BLE, V8::FBLE, // setle = bleu ble fble
+ V8::BCC, V8::BGE, V8::FBGE // setge = bcc bge fbge
+ };
+ unsigned Opcode = OpcodeTab[3*BranchIdx + Column];
+ BuildMI (BB, Opcode, 1).addMBB (takenSuccMBB);
+ BuildMI (BB, V8::BA, 1).addMBB (notTakenSuccMBB);
+ } else {
+ // goto takenSuccMBB;
+ BuildMI (BB, V8::BA, 1).addMBB (takenSuccMBB);
}
- // goto takenSuccMBB;
- BuildMI (BB, V8::BA, 1).addMBB (takenSuccMBB);
}
/// emitGEPOperation - Common code shared between visitGetElementPtrInst and
///
void V8ISel::emitGEPOperation (MachineBasicBlock *MBB,
MachineBasicBlock::iterator IP,
- Value *Src, User::op_iterator IdxBegin,
- User::op_iterator IdxEnd, unsigned TargetReg) {
+ Value *Src, User::op_iterator IdxBegin,
+ User::op_iterator IdxEnd, unsigned TargetReg) {
const TargetData &TD = TM.getTargetData ();
const Type *Ty = Src->getType ();
unsigned basePtrReg = getReg (Src, MBB, IP);
unsigned memberOffset =
TD.getStructLayout (StTy)->MemberOffsets[fieldIndex];
// Emit an ADD to add memberOffset to the basePtr.
- BuildMI (*MBB, IP, V8::ADDri, 2,
- nextBasePtrReg).addReg (basePtrReg).addZImm (memberOffset);
+ // We might have to copy memberOffset into a register first, if
+ // it's big.
+ if (memberOffset + 4096 < 8191) {
+ BuildMI (*MBB, IP, V8::ADDri, 2,
+ nextBasePtrReg).addReg (basePtrReg).addSImm (memberOffset);
+ } else {
+ unsigned offsetReg = makeAnotherReg (Type::IntTy);
+ copyConstantToRegister (MBB, IP,
+ ConstantSInt::get(Type::IntTy, memberOffset), offsetReg);
+ BuildMI (*MBB, IP, V8::ADDrr, 2,
+ nextBasePtrReg).addReg (basePtrReg).addReg (offsetReg);
+ }
// The next type is the member of the structure selected by the
// index.
Ty = StTy->getElementType (fieldIndex);
// type is the type of the elements in the array).
Ty = SqTy->getElementType ();
unsigned elementSize = TD.getTypeSize (Ty);
- unsigned idxReg = getReg (idx, MBB, IP);
- unsigned OffsetReg = makeAnotherReg (Type::IntTy);
- unsigned elementSizeReg = makeAnotherReg (Type::UIntTy);
- copyConstantToRegister (MBB, IP,
- ConstantUInt::get(Type::UIntTy, elementSize), elementSizeReg);
- // Emit a SMUL to multiply the register holding the index by
- // elementSize, putting the result in OffsetReg.
- BuildMI (*MBB, IP, V8::SMULrr, 2,
- OffsetReg).addReg (elementSizeReg).addReg (idxReg);
- // Emit an ADD to add OffsetReg to the basePtr.
- BuildMI (*MBB, IP, V8::ADDrr, 2,
- nextBasePtrReg).addReg (basePtrReg).addReg (OffsetReg);
+ unsigned OffsetReg = ~0U;
+ int64_t Offset = -1;
+ bool addImmed = false;
+ if (isa<ConstantIntegral> (idx)) {
+ // If idx is a constant, we don't have to emit the multiply.
+ int64_t Val = cast<ConstantIntegral> (idx)->getRawValue ();
+ if ((Val * elementSize) + 4096 < 8191) {
+ // (Val * elementSize) is constant and fits in an immediate field.
+ // emit: nextBasePtrReg = ADDri basePtrReg, (Val * elementSize)
+ addImmed = true;
+ Offset = Val * elementSize;
+ } else {
+ // (Val * elementSize) is constant, but doesn't fit in an immediate
+ // field. emit: OffsetReg = (Val * elementSize)
+ // nextBasePtrReg = ADDrr OffsetReg, basePtrReg
+ OffsetReg = makeAnotherReg (Type::IntTy);
+ copyConstantToRegister (MBB, IP,
+ ConstantSInt::get(Type::IntTy, Val * elementSize), OffsetReg);
+ }
+ } else {
+ // idx is not constant, we have to shift or multiply.
+ OffsetReg = makeAnotherReg (Type::IntTy);
+ unsigned idxReg = getReg (idx, MBB, IP);
+ switch (elementSize) {
+ case 1:
+ BuildMI (*MBB, IP, V8::ORrr, 2, OffsetReg).addReg (V8::G0).addReg (idxReg);
+ break;
+ case 2:
+ BuildMI (*MBB, IP, V8::SLLri, 2, OffsetReg).addReg (idxReg).addZImm (1);
+ break;
+ case 4:
+ BuildMI (*MBB, IP, V8::SLLri, 2, OffsetReg).addReg (idxReg).addZImm (2);
+ break;
+ case 8:
+ BuildMI (*MBB, IP, V8::SLLri, 2, OffsetReg).addReg (idxReg).addZImm (3);
+ break;
+ default: {
+ if (elementSize + 4096 < 8191) {
+ // Emit a SMUL to multiply the register holding the index by
+ // elementSize, putting the result in OffsetReg.
+ BuildMI (*MBB, IP, V8::SMULri, 2,
+ OffsetReg).addReg (idxReg).addSImm (elementSize);
+ } else {
+ unsigned elementSizeReg = makeAnotherReg (Type::UIntTy);
+ copyConstantToRegister (MBB, IP,
+ ConstantUInt::get(Type::UIntTy, elementSize), elementSizeReg);
+ // Emit a SMUL to multiply the register holding the index by
+ // the register w/ elementSize, putting the result in OffsetReg.
+ BuildMI (*MBB, IP, V8::SMULrr, 2,
+ OffsetReg).addReg (idxReg).addReg (elementSizeReg);
+ }
+ break;
+ }
+ }
+ }
+ if (addImmed) {
+ // Emit an ADD to add the constant immediate Offset to the basePtr.
+ BuildMI (*MBB, IP, V8::ADDri, 2,
+ nextBasePtrReg).addReg (basePtrReg).addSImm (Offset);
+ } else {
+ // Emit an ADD to add OffsetReg to the basePtr.
+ BuildMI (*MBB, IP, V8::ADDrr, 2,
+ nextBasePtrReg).addReg (basePtrReg).addReg (OffsetReg);
+ }
}
basePtrReg = nextBasePtrReg;
}
bool isSigned = I.getType()->isSigned();
switch (I.getOpcode ()) {
+ case Instruction::Shr: {
+ unsigned CarryReg = makeAnotherReg (Type::IntTy),
+ ThirtyTwo = makeAnotherReg (Type::IntTy),
+ HalfShiftReg = makeAnotherReg (Type::IntTy),
+ NegHalfShiftReg = makeAnotherReg (Type::IntTy),
+ TempReg = makeAnotherReg (Type::IntTy);
+ unsigned OneShiftOutReg = makeAnotherReg (Type::ULongTy),
+ TwoShiftsOutReg = makeAnotherReg (Type::ULongTy);
+
+ MachineBasicBlock *thisMBB = BB;
+ const BasicBlock *LLVM_BB = BB->getBasicBlock ();
+ MachineBasicBlock *shiftMBB = new MachineBasicBlock (LLVM_BB);
+ F->getBasicBlockList ().push_back (shiftMBB);
+ MachineBasicBlock *oneShiftMBB = new MachineBasicBlock (LLVM_BB);
+ F->getBasicBlockList ().push_back (oneShiftMBB);
+ MachineBasicBlock *twoShiftsMBB = new MachineBasicBlock (LLVM_BB);
+ F->getBasicBlockList ().push_back (twoShiftsMBB);
+ MachineBasicBlock *continueMBB = new MachineBasicBlock (LLVM_BB);
+ F->getBasicBlockList ().push_back (continueMBB);
+
+ // .lshr_begin:
+ // ...
+ // subcc %g0, ShiftAmtReg, %g0 ! Is ShAmt == 0?
+ // be .lshr_continue ! Then don't shift.
+ // ba .lshr_shift ! else shift.
+
+ BuildMI (BB, V8::SUBCCrr, 2, V8::G0).addReg (V8::G0)
+ .addReg (ShiftAmtReg);
+ BuildMI (BB, V8::BE, 1).addMBB (continueMBB);
+ BuildMI (BB, V8::BA, 1).addMBB (shiftMBB);
+
+ // Update machine-CFG edges
+ BB->addSuccessor (continueMBB);
+ BB->addSuccessor (shiftMBB);
+
+ // .lshr_shift: ! [preds: begin]
+ // or %g0, 32, ThirtyTwo
+ // subcc ThirtyTwo, ShiftAmtReg, HalfShiftReg ! Calculate 32 - shamt
+ // bg .lshr_two_shifts ! If >0, b two_shifts
+ // ba .lshr_one_shift ! else one_shift.
+
+ BB = shiftMBB;
+
+ BuildMI (BB, V8::ORri, 2, ThirtyTwo).addReg (V8::G0).addSImm (32);
+ BuildMI (BB, V8::SUBCCrr, 2, HalfShiftReg).addReg (ThirtyTwo)
+ .addReg (ShiftAmtReg);
+ BuildMI (BB, V8::BG, 1).addMBB (twoShiftsMBB);
+ BuildMI (BB, V8::BA, 1).addMBB (oneShiftMBB);
+
+ // Update machine-CFG edges
+ BB->addSuccessor (twoShiftsMBB);
+ BB->addSuccessor (oneShiftMBB);
+
+ // .lshr_two_shifts: ! [preds: shift]
+ // sll SrcReg, HalfShiftReg, CarryReg ! Save the borrows
+ // ! <SHIFT> in following is sra if signed, srl if unsigned
+ // <SHIFT> SrcReg, ShiftAmtReg, TwoShiftsOutReg ! Shift top half
+ // srl SrcReg+1, ShiftAmtReg, TempReg ! Shift bottom half
+ // or TempReg, CarryReg, TwoShiftsOutReg+1 ! Restore the borrows
+ // ba .lshr_continue
+ unsigned ShiftOpcode = (isSigned ? V8::SRArr : V8::SRLrr);
+
+ BB = twoShiftsMBB;
+
+ BuildMI (BB, V8::SLLrr, 2, CarryReg).addReg (SrcReg)
+ .addReg (HalfShiftReg);
+ BuildMI (BB, ShiftOpcode, 2, TwoShiftsOutReg).addReg (SrcReg)
+ .addReg (ShiftAmtReg);
+ BuildMI (BB, V8::SRLrr, 2, TempReg).addReg (SrcReg+1)
+ .addReg (ShiftAmtReg);
+ BuildMI (BB, V8::ORrr, 2, TwoShiftsOutReg+1).addReg (TempReg)
+ .addReg (CarryReg);
+ BuildMI (BB, V8::BA, 1).addMBB (continueMBB);
+
+ // Update machine-CFG edges
+ BB->addSuccessor (continueMBB);
+
+ // .lshr_one_shift: ! [preds: shift]
+ // ! if unsigned:
+ // or %g0, %g0, OneShiftOutReg ! Zero top half
+ // ! or, if signed:
+ // sra SrcReg, 31, OneShiftOutReg ! Sign-ext top half
+ // sub %g0, HalfShiftReg, NegHalfShiftReg ! Make ShiftAmt >0
+ // <SHIFT> SrcReg, NegHalfShiftReg, OneShiftOutReg+1 ! Shift bottom half
+ // ba .lshr_continue
+
+ BB = oneShiftMBB;
+
+ if (isSigned)
+ BuildMI (BB, V8::SRAri, 2, OneShiftOutReg).addReg (SrcReg).addZImm (31);
+ else
+ BuildMI (BB, V8::ORrr, 2, OneShiftOutReg).addReg (V8::G0)
+ .addReg (V8::G0);
+ BuildMI (BB, V8::SUBrr, 2, NegHalfShiftReg).addReg (V8::G0)
+ .addReg (HalfShiftReg);
+ BuildMI (BB, ShiftOpcode, 2, OneShiftOutReg+1).addReg (SrcReg)
+ .addReg (NegHalfShiftReg);
+ BuildMI (BB, V8::BA, 1).addMBB (continueMBB);
+
+ // Update machine-CFG edges
+ BB->addSuccessor (continueMBB);
+
+ // .lshr_continue: ! [preds: begin, do_one_shift, do_two_shifts]
+ // phi (SrcReg, begin), (TwoShiftsOutReg, two_shifts),
+ // (OneShiftOutReg, one_shift), DestReg ! Phi top half...
+ // phi (SrcReg+1, begin), (TwoShiftsOutReg+1, two_shifts),
+ // (OneShiftOutReg+1, one_shift), DestReg+1 ! And phi bottom half.
+
+ BB = continueMBB;
+ BuildMI (BB, V8::PHI, 6, DestReg).addReg (SrcReg).addMBB (thisMBB)
+ .addReg (TwoShiftsOutReg).addMBB (twoShiftsMBB)
+ .addReg (OneShiftOutReg).addMBB (oneShiftMBB);
+ BuildMI (BB, V8::PHI, 6, DestReg+1).addReg (SrcReg+1).addMBB (thisMBB)
+ .addReg (TwoShiftsOutReg+1).addMBB (twoShiftsMBB)
+ .addReg (OneShiftOutReg+1).addMBB (oneShiftMBB);
+ return;
+ }
case Instruction::Shl:
- case Instruction::Shr:
- if (!isSigned) {
- unsigned CarryReg = makeAnotherReg (Type::IntTy),
- ThirtyTwo = makeAnotherReg (Type::IntTy),
- HalfShiftReg = makeAnotherReg (Type::IntTy),
- NegHalfShiftReg = makeAnotherReg (Type::IntTy),
- TempReg = makeAnotherReg (Type::IntTy);
- unsigned OneShiftOutReg = makeAnotherReg (Type::ULongTy),
- TwoShiftsOutReg = makeAnotherReg (Type::ULongTy);
-
- /*
- .lshr_begin:
- ...
- // Check whether the shift amount is zero:
- V8::G0 = V8::SUBCCrr V8::G0, ShiftAmountReg
- V8::BE .lshr_continue
- V8::BA .lshr_shift
-
- .lshr_shift: // [preds: begin]
- // Calculate 32 - shamt:
- ThirtyTwo = V8::ORri V8::G0, 32
- HalfShiftReg = V8::SUBCCrr ThirtyTwo, ShiftAmountReg
- // See whether it was greater than 0:
- V8::BG .lshr_two_shifts
- V8::BA .lshr_one_shift
-
- .lshr_two_shifts: // [preds: shift]
- CarryReg = V8::SLLrr SrcReg, HalfShiftReg
- TwoShiftsOutReg = V8::SRLrr SrcReg, ShiftAmountReg
- TempReg = V8::SRLrr SrcReg+1, ShiftAmountReg
- TwoShiftsOutReg+1 = V8::ORrr TempReg, CarryReg
- V8::BA .lshr_continue
-
- .lshr_one_shift: // [preds: shift]
- OneShiftOutReg = V8::ORrr V8::G0, V8::G0
- NegHalfShiftReg = V8::SUBrr V8::G0, HalfShiftReg
- OneShiftOutReg+1 = V8::SRLrr SrcReg, NegHalfShiftReg
- V8::BA .lshr_continue
-
- .lshr_continue: // [preds: begin, do_one_shift, do_two_shifts]
- DestReg = V8::PHI (SrcReg, begin), (TwoShiftsOutReg, two_shifts),
- (OneShiftOutReg, one_shift)
- DestReg+1 = V8::PHI (SrcReg+1, begin), (TwoShiftsOutReg+1, two_shifts),
- (OneShiftOutReg+1, one_shift)
- ...
- */
-
- std::cerr << "Sorry, 64-bit lshr is not yet supported:\n" << I;
- abort ();
- return;
- }
default:
std::cerr << "Sorry, 64-bit shifts are not yet supported:\n" << I;
abort ();
void V8ISel::visitBinaryOperator (Instruction &I) {
unsigned DestReg = getReg (I);
unsigned Op0Reg = getReg (I.getOperand (0));
- unsigned Op1Reg = getReg (I.getOperand (1));
unsigned Class = getClassB (I.getType());
unsigned OpCase = ~0;
if (Class > cLong) {
+ unsigned Op1Reg = getReg (I.getOperand (1));
switch (I.getOpcode ()) {
case Instruction::Add: OpCase = 0; break;
case Instruction::Sub: OpCase = 1; break;
if (Class == cLong) {
const char *FuncName;
+ unsigned Op1Reg = getReg (I.getOperand (1));
DEBUG (std::cerr << "Class = cLong\n");
DEBUG (std::cerr << "Op0Reg = " << Op0Reg << ", " << Op0Reg+1 << "\n");
DEBUG (std::cerr << "Op1Reg = " << Op1Reg << ", " << Op1Reg+1 << "\n");
}
}
- // FIXME: support long, ulong.
switch (I.getOpcode ()) {
case Instruction::Add: OpCase = 0; break;
case Instruction::Sub: OpCase = 1; break;
case Instruction::Div:
case Instruction::Rem: {
unsigned Dest = ResultReg;
+ unsigned Op1Reg = getReg (I.getOperand (1));
if (I.getOpcode() == Instruction::Rem)
Dest = makeAnotherReg(I.getType());
unsigned Tmp = makeAnotherReg (I.getType ());
// Sign extend into the Y register
BuildMI (BB, V8::SRAri, 2, Tmp).addReg (Op0Reg).addZImm (31);
- BuildMI (BB, V8::WRrr, 2, V8::Y).addReg (Tmp).addReg (V8::G0);
+ BuildMI (BB, V8::WRYrr, 2).addReg (Tmp).addReg (V8::G0);
BuildMI (BB, V8::SDIVrr, 2, Dest).addReg (Op0Reg).addReg (Op1Reg);
} else {
// Zero extend into the Y register, ie, just set it to zero
- BuildMI (BB, V8::WRrr, 2, V8::Y).addReg (V8::G0).addReg (V8::G0);
+ BuildMI (BB, V8::WRYrr, 2).addReg (V8::G0).addReg (V8::G0);
BuildMI (BB, V8::UDIVrr, 2, Dest).addReg (Op0Reg).addReg (Op1Reg);
}
V8::ADDrr, V8::SUBrr, V8::SMULrr, V8::ANDrr, V8::ORrr, V8::XORrr,
V8::SLLrr, V8::SRLrr, V8::SRArr
};
+ static const unsigned OpcodesRI[] = {
+ V8::ADDri, V8::SUBri, V8::SMULri, V8::ANDri, V8::ORri, V8::XORri,
+ V8::SLLri, V8::SRLri, V8::SRAri
+ };
+ unsigned Op1Reg = ~0U;
if (OpCase != ~0U) {
- BuildMI (BB, Opcodes[OpCase], 2, ResultReg).addReg (Op0Reg).addReg (Op1Reg);
+ Value *Arg1 = I.getOperand (1);
+ bool useImmed = false;
+ int64_t Val = 0;
+ if ((getClassB (I.getType ()) <= cInt) && (isa<ConstantIntegral> (Arg1))) {
+ Val = cast<ConstantIntegral> (Arg1)->getRawValue ();
+ useImmed = (Val > -4096 && Val < 4095);
+ }
+ if (useImmed) {
+ BuildMI (BB, OpcodesRI[OpCase], 2, ResultReg).addReg (Op0Reg).addSImm (Val);
+ } else {
+ Op1Reg = getReg (I.getOperand (1));
+ BuildMI (BB, Opcodes[OpCase], 2, ResultReg).addReg (Op0Reg).addReg (Op1Reg);
+ }
}
switch (getClassB (I.getType ())) {
- case cByte:
+ case cByte:
if (I.getType ()->isSigned ()) { // add byte
BuildMI (BB, V8::ANDri, 2, DestReg).addReg (ResultReg).addZImm (0xff);
} else { // add ubyte
case cInt:
// Nothing to do here.
break;
- case cLong:
+ case cLong: {
// Only support and, or, xor here - others taken care of above.
if (OpCase < 3 || OpCase > 5) {
visitInstruction (I);
BuildMI (BB, Opcodes[OpCase], 2, ResultReg+1).addReg (Op0Reg+1)
.addReg (Op1Reg+1);
break;
+ }
default:
visitInstruction (I);
}
}
void V8ISel::visitSetCondInst(SetCondInst &I) {
+ if (canFoldSetCCIntoBranch(&I))
+ return; // Fold this into a branch.
+
unsigned Op0Reg = getReg (I.getOperand (0));
unsigned Op1Reg = getReg (I.getOperand (1));
unsigned DestReg = getReg (I);
const Type *Ty = I.getOperand (0)->getType ();
-
+
// Compare the two values.
if (getClass (Ty) < cLong) {
BuildMI(BB, V8::SUBCCrr, 2, V8::G0).addReg(Op0Reg).addReg(Op1Reg);
// thisMBB:
// ...
// subcc %reg0, %reg1, %g0
- // bCC copy1MBB
- // ba copy0MBB
-
- // FIXME: we wouldn't need copy0MBB (we could fold it into thisMBB)
- // if we could insert other, non-terminator instructions after the
- // bCC. But MBB->getFirstTerminator() can't understand this.
- MachineBasicBlock *copy1MBB = new MachineBasicBlock (LLVM_BB);
- F->getBasicBlockList ().push_back (copy1MBB);
- BuildMI (BB, Opcode, 1).addMBB (copy1MBB);
+ // TrueVal = or G0, 1
+ // bCC sinkMBB
+
+ unsigned TrueValue = makeAnotherReg (I.getType ());
+ BuildMI (BB, V8::ORri, 2, TrueValue).addReg (V8::G0).addZImm (1);
+
MachineBasicBlock *copy0MBB = new MachineBasicBlock (LLVM_BB);
- F->getBasicBlockList ().push_back (copy0MBB);
- BuildMI (BB, V8::BA, 1).addMBB (copy0MBB);
+ MachineBasicBlock *sinkMBB = new MachineBasicBlock (LLVM_BB);
+ BuildMI (BB, Opcode, 1).addMBB (sinkMBB);
+
// Update machine-CFG edges
- BB->addSuccessor (copy1MBB);
+ BB->addSuccessor (sinkMBB);
BB->addSuccessor (copy0MBB);
// copy0MBB:
// %FalseValue = or %G0, 0
- // ba sinkMBB
+ // # fall through
BB = copy0MBB;
+ F->getBasicBlockList ().push_back (BB);
unsigned FalseValue = makeAnotherReg (I.getType ());
- BuildMI (BB, V8::ORri, 2, FalseValue).addReg (V8::G0).addZImm (0);
- MachineBasicBlock *sinkMBB = new MachineBasicBlock (LLVM_BB);
- F->getBasicBlockList ().push_back (sinkMBB);
- BuildMI (BB, V8::BA, 1).addMBB (sinkMBB);
+ BuildMI (BB, V8::ORrr, 2, FalseValue).addReg (V8::G0).addReg (V8::G0);
+
// Update machine-CFG edges
BB->addSuccessor (sinkMBB);
DEBUG (std::cerr << "thisMBB is at " << (void*)thisMBB << "\n");
- DEBUG (std::cerr << "copy1MBB is at " << (void*)copy1MBB << "\n");
DEBUG (std::cerr << "copy0MBB is at " << (void*)copy0MBB << "\n");
DEBUG (std::cerr << "sinkMBB is at " << (void*)sinkMBB << "\n");
- // copy1MBB:
- // %TrueValue = or %G0, 1
- // ba sinkMBB
- BB = copy1MBB;
- unsigned TrueValue = makeAnotherReg (I.getType ());
- BuildMI (BB, V8::ORri, 2, TrueValue).addReg (V8::G0).addZImm (1);
- BuildMI (BB, V8::BA, 1).addMBB (sinkMBB);
- // Update machine-CFG edges
- BB->addSuccessor (sinkMBB);
-
// sinkMBB:
- // %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, copy1MBB ]
+ // %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
// ...
BB = sinkMBB;
+ F->getBasicBlockList ().push_back (BB);
BuildMI (BB, V8::PHI, 4, DestReg).addReg (FalseValue)
- .addMBB (copy0MBB).addReg (TrueValue).addMBB (copy1MBB);
+ .addMBB (copy0MBB).addReg (TrueValue).addMBB (thisMBB);
}
void V8ISel::visitAllocaInst(AllocaInst &I) {
BuildMI (BB, V8::ANDri, 2, StackAdjReg).addReg (TmpReg2).addSImm (-8);
// Subtract size from stack pointer, thereby allocating some space.
- BuildMI (BB, V8::SUBrr, 2, V8::SP).addReg (V8::SP).addReg (StackAdjReg);
+ BuildMI (BB, V8::SUBrr, 2, V8::O6).addReg (V8::O6).addReg (StackAdjReg);
// Put a pointer to the space into the result register, by copying
// the stack pointer.
- BuildMI (BB, V8::ADDri, 2, getReg(I)).addReg (V8::SP).addSImm (96);
+ BuildMI (BB, V8::ADDri, 2, getReg(I)).addReg (V8::O6).addSImm (96);
// Inform the Frame Information that we have just allocated a variable-sized
// object.
case Intrinsic::vastart: {
// Add the VarArgsOffset to the frame pointer, and copy it to the result.
- unsigned DestReg = getReg (CI);
- BuildMI (BB, V8::ADDri, 2, DestReg).addReg (V8::FP).addSImm (VarArgsOffset);
+ unsigned DestReg = getReg (CI.getOperand(1));
+ unsigned Tmp = makeAnotherReg(Type::IntTy);
+ BuildMI (BB, V8::ADDri, 2, Tmp).addReg (V8::I6).addSImm (VarArgsOffset);
+ BuildMI(BB, V8::STri, 3).addReg(DestReg).addSImm(0).addReg(Tmp);
return;
}
case Intrinsic::vacopy: {
// Copy the va_list ptr (arg1) to the result.
- unsigned DestReg = getReg (CI), SrcReg = getReg (CI.getOperand (1));
- BuildMI (BB, V8::ORrr, 2, DestReg).addReg (V8::G0).addReg (SrcReg);
+ unsigned DestReg = getReg (CI.getOperand(1)), SrcReg = getReg (CI.getOperand (2));
+ BuildMI(BB, V8::STri, 3).addReg(DestReg).addSImm(0).addReg(SrcReg);
return;
}
}
}
-void V8ISel::visitVANextInst (VANextInst &I) {
- // Add the type size to the vararg pointer (arg0).
- unsigned DestReg = getReg (I);
- unsigned SrcReg = getReg (I.getOperand (0));
- unsigned TySize = TM.getTargetData ().getTypeSize (I.getArgType ());
- BuildMI (BB, V8::ADDri, 2, DestReg).addReg (SrcReg).addSImm (TySize);
-}
-
void V8ISel::visitVAArgInst (VAArgInst &I) {
- unsigned VAList = getReg (I.getOperand (0));
+ unsigned VAListPtr = getReg (I.getOperand (0));
unsigned DestReg = getReg (I);
+ unsigned Size;
+ unsigned VAList = makeAnotherReg(Type::IntTy);
+ BuildMI(BB, V8::LDri, 2, VAList).addReg(VAListPtr).addSImm(0);
switch (I.getType ()->getTypeID ()) {
case Type::PointerTyID:
case Type::UIntTyID:
case Type::IntTyID:
- BuildMI (BB, V8::LD, 2, DestReg).addReg (VAList).addSImm (0);
- return;
+ Size = 4;
+ BuildMI (BB, V8::LDri, 2, DestReg).addReg (VAList).addSImm (0);
+ break;
case Type::ULongTyID:
case Type::LongTyID:
- BuildMI (BB, V8::LD, 2, DestReg).addReg (VAList).addSImm (0);
- BuildMI (BB, V8::LD, 2, DestReg+1).addReg (VAList).addSImm (4);
- return;
+ Size = 8;
+ BuildMI (BB, V8::LDri, 2, DestReg).addReg (VAList).addSImm (0);
+ BuildMI (BB, V8::LDri, 2, DestReg+1).addReg (VAList).addSImm (4);
+ break;
case Type::DoubleTyID: {
+ Size = 8;
unsigned DblAlign = TM.getTargetData().getDoubleAlignment();
unsigned TempReg = makeAnotherReg (Type::IntTy);
unsigned TempReg2 = makeAnotherReg (Type::IntTy);
int FI = F->getFrameInfo()->CreateStackObject(8, DblAlign);
- BuildMI (BB, V8::LD, 2, TempReg).addReg (VAList).addSImm (0);
- BuildMI (BB, V8::LD, 2, TempReg2).addReg (VAList).addSImm (4);
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (0).addReg (TempReg);
- BuildMI (BB, V8::ST, 3).addFrameIndex (FI).addSImm (4).addReg (TempReg2);
+ BuildMI (BB, V8::LDri, 2, TempReg).addReg (VAList).addSImm (0);
+ BuildMI (BB, V8::LDri, 2, TempReg2).addReg (VAList).addSImm (4);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (0).addReg (TempReg);
+ BuildMI (BB, V8::STri, 3).addFrameIndex (FI).addSImm (4).addReg (TempReg2);
BuildMI (BB, V8::LDDFri, 2, DestReg).addFrameIndex (FI).addSImm (0);
- return;
+ break;
}
default:
abort ();
return;
}
+ unsigned tmp = makeAnotherReg(Type::IntTy);
+ BuildMI (BB, V8::ADDri, 2, tmp).addReg(VAList).addSImm(Size);
+ BuildMI(BB, V8::STri, 3).addReg(VAListPtr).addSImm(0).addReg(VAList);
+ return;
}
projects / oota-llvm.git / blobdiff