maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Implement sseregparm. 

llvm-svn: 46764
This commit is contained in:
Dale Johannesen 2008-02-05 20:46:33 +00:00
parent 8d78b0597b
commit d88f1d060e
3 changed files with 23 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/include/llvm/CallingConv.h
View File

@ -57,7 +57,11 @@ namespace CallingConv {
/// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments /// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments
/// in ECX:EDX registers, others - via stack. Callee is responsible for /// in ECX:EDX registers, others - via stack. Callee is responsible for
/// stack cleaning. /// stack cleaning.
X86_FastCall = 65 X86_FastCall = 65,
/// X86_SSEreg - The standard convention except that float and double
/// values are returned in XMM0 if SSE support is available.
X86_SSECall = 66
}; };
} // End CallingConv namespace } // End CallingConv namespace

18
llvm/lib/Target/X86/X86CallingConv.td
View File

@ -61,6 +61,15 @@ def RetCC_X86_32_Fast : CallingConv<[
CCDelegateTo<RetCC_X86Common> CCDelegateTo<RetCC_X86Common>
]>; ]>;
// X86-32 SSEregparm return-value convention.
def RetCC_X86_32_SSE : CallingConv<[
// The X86-32 sseregparm calling convention returns FP values in XMM0 if the
// target has SSE2, otherwise it is the C calling convention.
CCIfType<[f32], CCIfSubtarget<"hasSSE2()", CCAssignToReg<[XMM0]>>>,
CCIfType<[f64], CCIfSubtarget<"hasSSE2()", CCAssignToReg<[XMM0]>>>,
CCDelegateTo<RetCC_X86Common>
]>;
// X86-64 C return-value convention. // X86-64 C return-value convention.
def RetCC_X86_64_C : CallingConv<[ def RetCC_X86_64_C : CallingConv<[
// The X86-64 calling convention always returns FP values in XMM0. // The X86-64 calling convention always returns FP values in XMM0.
@ -69,12 +78,12 @@ def RetCC_X86_64_C : CallingConv<[
CCDelegateTo<RetCC_X86Common> CCDelegateTo<RetCC_X86Common>
]>; ]>;
// This is the root return-value convention for the X86-32 backend. // This is the root return-value convention for the X86-32 backend.
def RetCC_X86_32 : CallingConv<[ def RetCC_X86_32 : CallingConv<[
// If FastCC, use RetCC_X86_32_Fast. // If FastCC, use RetCC_X86_32_Fast.
CCIfCC<"CallingConv::Fast", CCDelegateTo<RetCC_X86_32_Fast>>, CCIfCC<"CallingConv::Fast", CCDelegateTo<RetCC_X86_32_Fast>>,
// If SSECC, use RetCC_X86_32_SSE.
CCIfCC<"CallingConv::X86_SSECall", CCDelegateTo<RetCC_X86_32_SSE>>,
// Otherwise, use RetCC_X86_32_C. // Otherwise, use RetCC_X86_32_C.
CCDelegateTo<RetCC_X86_32_C> CCDelegateTo<RetCC_X86_32_C>
]>; ]>;
@ -179,6 +188,11 @@ def CC_X86_32_Common : CallingConv<[
// Handles byval parameters. // Handles byval parameters.
CCIfByVal<CCPassByVal<4, 4>>, CCIfByVal<CCPassByVal<4, 4>>,
// The first 3 float or double arguments, if marked 'inreg' and if the call
// is not a vararg call and if SSE2 is available, are passed in SSE registers.
CCIfNotVarArg<CCIfInReg<CCIfType<[f32,f64], CCIfSubtarget<"hasSSE2()",
CCAssignToReg<[XMM0,XMM1,XMM2]>>>>>,
// Integer/Float values get stored in stack slots that are 4 bytes in // Integer/Float values get stored in stack slots that are 4 bytes in
// size and 4-byte aligned. // size and 4-byte aligned.
CCIfType<[i32, f32], CCAssignToStack<4, 4>>, CCIfType<[i32, f32], CCAssignToStack<4, 4>>,

4
llvm/lib/Target/X86/X86ISelLowering.cpp
View File

@ -1137,9 +1137,9 @@ X86TargetLowering::LowerFORMAL_ARGUMENTS(SDOperand Op, SelectionDAG &DAG) {
RC = X86::GR32RegisterClass; RC = X86::GR32RegisterClass;
else if (Is64Bit && RegVT == MVT::i64) else if (Is64Bit && RegVT == MVT::i64)
RC = X86::GR64RegisterClass; RC = X86::GR64RegisterClass;
else if (Is64Bit && RegVT == MVT::f32) else if (RegVT == MVT::f32)
RC = X86::FR32RegisterClass; RC = X86::FR32RegisterClass;
else if (Is64Bit && RegVT == MVT::f64) else if (RegVT == MVT::f64)
RC = X86::FR64RegisterClass; RC = X86::FR64RegisterClass;
else { else {
assert(MVT::isVector(RegVT)); assert(MVT::isVector(RegVT));