RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-10 22:43:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix some really strange indentation that xcode likes to use.

Browse Source 
no xcode, this is not right:

   if (!foo) break;
     X;


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23138 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2005-08-30 00:19:00 +00:00
parent 8bbcc20a9d
commit 915fb302b1
1 changed files with 158 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

315
lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -199,63 +199,63 @@ PPC32TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
MVT::ValueType ObjectVT = getValueType(I->getType()); MVT::ValueType ObjectVT = getValueType(I->getType());
switch (ObjectVT) { switch (ObjectVT) {
default: assert(0 && "Unhandled argument type!"); default: assert(0 && "Unhandled argument type!");
case MVT::i1: case MVT::i1:
case MVT::i8: case MVT::i8:
case MVT::i16: case MVT::i16:
case MVT::i32: case MVT::i32:
ObjSize = 4; ObjSize = 4;
if (!ArgLive) break; if (!ArgLive) break;
if (GPR_remaining > 0) { if (GPR_remaining > 0) {
MF.addLiveIn(GPR[GPR_idx]); MF.addLiveIn(GPR[GPR_idx]);
argt = newroot = DAG.getCopyFromReg(DAG.getRoot(), argt = newroot = DAG.getCopyFromReg(DAG.getRoot(),
GPR[GPR_idx], MVT::i32); GPR[GPR_idx], MVT::i32);
if (ObjectVT != MVT::i32) if (ObjectVT != MVT::i32)
argt = DAG.getNode(ISD::TRUNCATE, ObjectVT, newroot); argt = DAG.getNode(ISD::TRUNCATE, ObjectVT, newroot);
} else { } else {
needsLoad = true; needsLoad = true;
} }
break; break;
case MVT::i64: ObjSize = 8; case MVT::i64: ObjSize = 8;
if (!ArgLive) break; if (!ArgLive) break;
if (GPR_remaining > 0) { if (GPR_remaining > 0) {
SDOperand argHi, argLo; SDOperand argHi, argLo;
MF.addLiveIn(GPR[GPR_idx]); MF.addLiveIn(GPR[GPR_idx]);
argHi = DAG.getCopyFromReg(DAG.getRoot(), GPR[GPR_idx], MVT::i32); argHi = DAG.getCopyFromReg(DAG.getRoot(), GPR[GPR_idx], MVT::i32);
// If we have two or more remaining argument registers, then both halves // If we have two or more remaining argument registers, then both halves
// of the i64 can be sourced from there. Otherwise, the lower half will // of the i64 can be sourced from there. Otherwise, the lower half will
// have to come off the stack. This can happen when an i64 is preceded // have to come off the stack. This can happen when an i64 is preceded
// by 28 bytes of arguments. // by 28 bytes of arguments.
if (GPR_remaining > 1) { if (GPR_remaining > 1) {
MF.addLiveIn(GPR[GPR_idx+1]); MF.addLiveIn(GPR[GPR_idx+1]);
argLo = DAG.getCopyFromReg(argHi, GPR[GPR_idx+1], MVT::i32); argLo = DAG.getCopyFromReg(argHi, GPR[GPR_idx+1], MVT::i32);
} else { } else {
int FI = MFI->CreateFixedObject(4, ArgOffset+4); int FI = MFI->CreateFixedObject(4, ArgOffset+4);
SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32); SDOperand FIN = DAG.getFrameIndex(FI, MVT::i32);
argLo = DAG.getLoad(MVT::i32, DAG.getEntryNode(), FIN, argLo = DAG.getLoad(MVT::i32, DAG.getEntryNode(), FIN,
DAG.getSrcValue(NULL)); DAG.getSrcValue(NULL));
} }
// Build the outgoing arg thingy // Build the outgoing arg thingy
argt = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, argLo, argHi); argt = DAG.getNode(ISD::BUILD_PAIR, MVT::i64, argLo, argHi);
newroot = argLo; newroot = argLo;
} else { } else {
needsLoad = true; needsLoad = true;
} }
break; break;
case MVT::f32: case MVT::f32:
case MVT::f64: case MVT::f64:
ObjSize = (ObjectVT == MVT::f64) ? 8 : 4; ObjSize = (ObjectVT == MVT::f64) ? 8 : 4;
if (!ArgLive) break; if (!ArgLive) break;
if (FPR_remaining > 0) { if (FPR_remaining > 0) {
MF.addLiveIn(FPR[FPR_idx]); MF.addLiveIn(FPR[FPR_idx]);
argt = newroot = DAG.getCopyFromReg(DAG.getRoot(), argt = newroot = DAG.getCopyFromReg(DAG.getRoot(),
FPR[FPR_idx], ObjectVT); FPR[FPR_idx], ObjectVT);
--FPR_remaining; --FPR_remaining;
++FPR_idx; ++FPR_idx;
} else { } else {
needsLoad = true; needsLoad = true;
} }
break; break;
} }
// We need to load the argument to a virtual register if we determined above // We need to load the argument to a virtual register if we determined above
@ -349,26 +349,27 @@ PPC32TargetLowering::LowerCallTo(SDOperand Chain,
Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain, Chain = DAG.getNode(ISD::CALLSEQ_START, MVT::Other, Chain,
DAG.getConstant(NumBytes, getPointerTy())); DAG.getConstant(NumBytes, getPointerTy()));
} else { } else {
for (unsigned i = 0, e = Args.size(); i != e; ++i) for (unsigned i = 0, e = Args.size(); i != e; ++i) {
switch (getValueType(Args[i].second)) { switch (getValueType(Args[i].second)) {
default: assert(0 && "Unknown value type!"); default: assert(0 && "Unknown value type!");
case MVT::i1: case MVT::i1:
case MVT::i8: case MVT::i8:
case MVT::i16: case MVT::i16:
case MVT::i32: case MVT::i32:
case MVT::f32: case MVT::f32:
NumBytes += 4; NumBytes += 4;
break; break;
case MVT::i64: case MVT::i64:
case MVT::f64: case MVT::f64:
NumBytes += 8; NumBytes += 8;
break; break;
} }
}
// Just to be safe, we'll always reserve the full 24 bytes of linkage area // Just to be safe, we'll always reserve the full 24 bytes of linkage area
// plus 32 bytes of argument space in case any called code gets funky on us. // plus 32 bytes of argument space in case any called code gets funky on us.
// (Required by ABI to support var arg) // (Required by ABI to support var arg)
if (NumBytes < 56) NumBytes = 56; if (NumBytes < 56) NumBytes = 56;
// Adjust the stack pointer for the new arguments... // Adjust the stack pointer for the new arguments...
// These operations are automatically eliminated by the prolog/epilog pass // These operations are automatically eliminated by the prolog/epilog pass
@ -398,102 +399,102 @@ PPC32TargetLowering::LowerCallTo(SDOperand Chain,
MVT::ValueType ArgVT = getValueType(Args[i].second); MVT::ValueType ArgVT = getValueType(Args[i].second);
switch (ArgVT) { switch (ArgVT) {
default: assert(0 && "Unexpected ValueType for argument!"); default: assert(0 && "Unexpected ValueType for argument!");
case MVT::i1: case MVT::i1:
case MVT::i8: case MVT::i8:
case MVT::i16: case MVT::i16:
// Promote the integer to 32 bits. If the input type is signed use a // Promote the integer to 32 bits. If the input type is signed use a
// sign extend, otherwise use a zero extend. // sign extend, otherwise use a zero extend.
if (Args[i].second->isSigned()) if (Args[i].second->isSigned())
Args[i].first =DAG.getNode(ISD::SIGN_EXTEND, MVT::i32, Args[i].first); Args[i].first =DAG.getNode(ISD::SIGN_EXTEND, MVT::i32, Args[i].first);
else else
Args[i].first =DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Args[i].first); Args[i].first =DAG.getNode(ISD::ZERO_EXTEND, MVT::i32, Args[i].first);
// FALL THROUGH // FALL THROUGH
case MVT::i32: case MVT::i32:
if (GPR_remaining > 0) {
args_to_use.push_back(Args[i].first);
--GPR_remaining;
} else {
MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
Args[i].first, PtrOff,
DAG.getSrcValue(NULL)));
}
ArgOffset += 4;
break;
case MVT::i64:
// If we have one free GPR left, we can place the upper half of the i64
// in it, and store the other half to the stack. If we have two or more
// free GPRs, then we can pass both halves of the i64 in registers.
if (GPR_remaining > 0) {
SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
Args[i].first, DAG.getConstant(1, MVT::i32));
SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32,
Args[i].first, DAG.getConstant(0, MVT::i32));
args_to_use.push_back(Hi);
--GPR_remaining;
if (GPR_remaining > 0) { if (GPR_remaining > 0) {
args_to_use.push_back(Args[i].first); args_to_use.push_back(Lo);
--GPR_remaining; --GPR_remaining;
} else { } else {
SDOperand ConstFour = DAG.getConstant(4, getPointerTy());
PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour);
MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain, MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
Args[i].first, PtrOff, Lo, PtrOff, DAG.getSrcValue(NULL)));
DAG.getSrcValue(NULL)));
} }
ArgOffset += 4; } else {
break; MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
case MVT::i64: Args[i].first, PtrOff,
// If we have one free GPR left, we can place the upper half of the i64 DAG.getSrcValue(NULL)));
// in it, and store the other half to the stack. If we have two or more }
// free GPRs, then we can pass both halves of the i64 in registers. ArgOffset += 8;
if (GPR_remaining > 0) { break;
SDOperand Hi = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, case MVT::f32:
Args[i].first, DAG.getConstant(1, MVT::i32)); case MVT::f64:
SDOperand Lo = DAG.getNode(ISD::EXTRACT_ELEMENT, MVT::i32, if (FPR_remaining > 0) {
Args[i].first, DAG.getConstant(0, MVT::i32)); args_to_use.push_back(Args[i].first);
args_to_use.push_back(Hi); --FPR_remaining;
--GPR_remaining; if (isVarArg) {
SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, Chain,
Args[i].first, PtrOff,
DAG.getSrcValue(NULL));
MemOps.push_back(Store);
// Float varargs are always shadowed in available integer registers
if (GPR_remaining > 0) { if (GPR_remaining > 0) {
args_to_use.push_back(Lo); SDOperand Load = DAG.getLoad(MVT::i32, Store, PtrOff,
DAG.getSrcValue(NULL));
MemOps.push_back(Load);
args_to_use.push_back(Load);
--GPR_remaining; --GPR_remaining;
} else { }
if (GPR_remaining > 0 && MVT::f64 == ArgVT) {
SDOperand ConstFour = DAG.getConstant(4, getPointerTy()); SDOperand ConstFour = DAG.getConstant(4, getPointerTy());
PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour); PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour);
MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain, SDOperand Load = DAG.getLoad(MVT::i32, Store, PtrOff,
Lo, PtrOff, DAG.getSrcValue(NULL))); DAG.getSrcValue(NULL));
MemOps.push_back(Load);
args_to_use.push_back(Load);
--GPR_remaining;
} }
} else { } else {
MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain, // If we have any FPRs remaining, we may also have GPRs remaining.
Args[i].first, PtrOff, // Args passed in FPRs consume either 1 (f32) or 2 (f64) available
DAG.getSrcValue(NULL))); // GPRs.
} if (GPR_remaining > 0) {
ArgOffset += 8; args_to_use.push_back(DAG.getNode(ISD::UNDEF, MVT::i32));
break; --GPR_remaining;
case MVT::f32: }
case MVT::f64: if (GPR_remaining > 0 && MVT::f64 == ArgVT) {
if (FPR_remaining > 0) { args_to_use.push_back(DAG.getNode(ISD::UNDEF, MVT::i32));
args_to_use.push_back(Args[i].first); --GPR_remaining;
--FPR_remaining;
if (isVarArg) {
SDOperand Store = DAG.getNode(ISD::STORE, MVT::Other, Chain,
Args[i].first, PtrOff,
DAG.getSrcValue(NULL));
MemOps.push_back(Store);
// Float varargs are always shadowed in available integer registers
if (GPR_remaining > 0) {
SDOperand Load = DAG.getLoad(MVT::i32, Store, PtrOff,
DAG.getSrcValue(NULL));
MemOps.push_back(Load);
args_to_use.push_back(Load);
--GPR_remaining;
}
if (GPR_remaining > 0 && MVT::f64 == ArgVT) {
SDOperand ConstFour = DAG.getConstant(4, getPointerTy());
PtrOff = DAG.getNode(ISD::ADD, MVT::i32, PtrOff, ConstFour);
SDOperand Load = DAG.getLoad(MVT::i32, Store, PtrOff,
DAG.getSrcValue(NULL));
MemOps.push_back(Load);
args_to_use.push_back(Load);
--GPR_remaining;
}
} else {
// If we have any FPRs remaining, we may also have GPRs remaining.
// Args passed in FPRs consume either 1 (f32) or 2 (f64) available
// GPRs.
if (GPR_remaining > 0) {
args_to_use.push_back(DAG.getNode(ISD::UNDEF, MVT::i32));
--GPR_remaining;
}
if (GPR_remaining > 0 && MVT::f64 == ArgVT) {
args_to_use.push_back(DAG.getNode(ISD::UNDEF, MVT::i32));
--GPR_remaining;
}
} }
} else {
MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
Args[i].first, PtrOff,
DAG.getSrcValue(NULL)));
} }
ArgOffset += (ArgVT == MVT::f32) ? 4 : 8; } else {
break; MemOps.push_back(DAG.getNode(ISD::STORE, MVT::Other, Chain,
Args[i].first, PtrOff,
DAG.getSrcValue(NULL)));
}
ArgOffset += (ArgVT == MVT::f32) ? 4 : 8;
break;
} }
} }
if (!MemOps.empty()) if (!MemOps.empty())