2009-04-01 00:51:18 +08:00
|
|
|
//===-- CallingConvLower.cpp - Calling Conventions ------------------------===//
|
2007-02-27 12:43:02 +08:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2007-02-27 12:43:02 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the CCState class, used for lowering and implementing
|
|
|
|
// calling conventions.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/CodeGen/CallingConvLower.h"
|
2011-06-09 07:55:35 +08:00
|
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2010-01-05 09:24:50 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-11 21:10:19 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-03-01 01:17:53 +08:00
|
|
|
#include "llvm/Target/TargetLowering.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
2007-02-27 12:43:02 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2011-06-09 07:55:35 +08:00
|
|
|
CCState::CCState(CallingConv::ID CC, bool isVarArg, MachineFunction &mf,
|
2011-06-11 04:31:39 +08:00
|
|
|
const TargetMachine &tm, SmallVector<CCValAssign, 16> &locs,
|
|
|
|
LLVMContext &C)
|
2011-06-09 07:55:35 +08:00
|
|
|
: CallingConv(CC), IsVarArg(isVarArg), MF(mf), TM(tm),
|
2011-04-21 00:47:52 +08:00
|
|
|
TRI(*TM.getRegisterInfo()), Locs(locs), Context(C),
|
2011-06-11 04:37:36 +08:00
|
|
|
CallOrPrologue(Unknown) {
|
2007-02-27 12:43:02 +08:00
|
|
|
// No stack is used.
|
|
|
|
StackOffset = 0;
|
2011-06-09 07:55:35 +08:00
|
|
|
|
2011-04-21 00:47:52 +08:00
|
|
|
clearFirstByValReg();
|
2008-07-01 04:25:31 +08:00
|
|
|
UsedRegs.resize((TRI.getNumRegs()+31)/32);
|
2007-02-27 12:43:02 +08:00
|
|
|
}
|
|
|
|
|
2011-06-09 07:55:35 +08:00
|
|
|
// HandleByVal - Allocate space on the stack large enough to pass an argument
|
|
|
|
// by value. The size and alignment information of the argument is encoded in
|
|
|
|
// its parameter attribute.
|
2010-11-04 18:49:57 +08:00
|
|
|
void CCState::HandleByVal(unsigned ValNo, MVT ValVT,
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT LocVT, CCValAssign::LocInfo LocInfo,
|
2008-01-15 15:49:36 +08:00
|
|
|
int MinSize, int MinAlign,
|
2008-03-21 17:14:45 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags) {
|
|
|
|
unsigned Align = ArgFlags.getByValAlign();
|
|
|
|
unsigned Size = ArgFlags.getByValSize();
|
2008-01-15 15:49:36 +08:00
|
|
|
if (MinSize > (int)Size)
|
|
|
|
Size = MinSize;
|
|
|
|
if (MinAlign > (int)Align)
|
|
|
|
Align = MinAlign;
|
2012-06-20 06:59:12 +08:00
|
|
|
MF.getFrameInfo()->ensureMaxAlignment(Align);
|
Issue:
Stack is formed improperly for long structures passed as byval arguments for
EABI mode.
If we took AAPCS reference, we can found the next statements:
A: "If the argument requires double-word alignment (8-byte), the NCRN (Next
Core Register Number) is rounded up to the next even register number." (5.5
Parameter Passing, Stage C, C.3).
B: "The alignment of an aggregate shall be the alignment of its most-aligned
component." (4.3 Composite Types, 4.3.1 Aggregates).
So if we have structure with doubles (9 double fields) and 3 Core unused
registers (r1, r2, r3): caller should use r2 and r3 registers only.
Currently r1,r2,r3 set is used, but it is invalid.
Callee VA routine should also use r2 and r3 regs only. All is ok here. This
behaviour is guessed by rounding up SP address with ADD+BFC operations.
Fix:
Main fix is in ARMTargetLowering::HandleByVal. If we detected AAPCS mode and
8 byte alignment, we waste odd registers then.
P.S.:
I also improved LDRB_POST_IMM regression test. Since ldrb instruction will
not generated by current regression test after this patch.
llvm-svn: 166018
2012-10-16 15:16:47 +08:00
|
|
|
TM.getTargetLowering()->HandleByVal(this, Size, Align);
|
2011-05-26 12:09:49 +08:00
|
|
|
unsigned Offset = AllocateStack(Size, Align);
|
|
|
|
addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
|
2007-08-10 22:44:42 +08:00
|
|
|
}
|
2007-02-27 12:43:02 +08:00
|
|
|
|
|
|
|
/// MarkAllocated - Mark a register and all of its aliases as allocated.
|
|
|
|
void CCState::MarkAllocated(unsigned Reg) {
|
2012-06-02 07:28:30 +08:00
|
|
|
for (MCRegAliasIterator AI(Reg, &TRI, true); AI.isValid(); ++AI)
|
|
|
|
UsedRegs[*AI/32] |= 1 << (*AI&31);
|
2007-02-27 12:43:02 +08:00
|
|
|
}
|
2007-02-28 14:56:37 +08:00
|
|
|
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
/// AnalyzeFormalArguments - Analyze an array of argument values,
|
2007-02-28 15:09:40 +08:00
|
|
|
/// incorporating info about the formals into this state.
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
void
|
|
|
|
CCState::AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
CCAssignFn Fn) {
|
|
|
|
unsigned NumArgs = Ins.size();
|
|
|
|
|
2007-02-28 15:09:40 +08:00
|
|
|
for (unsigned i = 0; i != NumArgs; ++i) {
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT ArgVT = Ins[i].VT;
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags = Ins[i].Flags;
|
2007-02-28 15:09:40 +08:00
|
|
|
if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
|
2009-07-15 00:55:14 +08:00
|
|
|
#ifndef NDEBUG
|
2010-01-05 09:24:50 +08:00
|
|
|
dbgs() << "Formal argument #" << i << " has unhandled type "
|
2012-11-14 13:20:09 +08:00
|
|
|
<< EVT(ArgVT).getEVTString() << '\n';
|
2009-07-15 00:55:14 +08:00
|
|
|
#endif
|
|
|
|
llvm_unreachable(0);
|
2007-02-28 15:09:40 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-07 10:11:54 +08:00
|
|
|
/// CheckReturn - Analyze the return values of a function, returning true if
|
|
|
|
/// the return can be performed without sret-demotion, and false otherwise.
|
2010-07-10 17:00:22 +08:00
|
|
|
bool CCState::CheckReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
|
2009-11-07 10:11:54 +08:00
|
|
|
CCAssignFn Fn) {
|
|
|
|
// Determine which register each value should be copied into.
|
2010-07-10 17:00:22 +08:00
|
|
|
for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT VT = Outs[i].VT;
|
2010-07-10 17:00:22 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
|
2009-11-07 10:11:54 +08:00
|
|
|
if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
/// AnalyzeReturn - Analyze the returned values of a return,
|
2007-02-28 15:09:40 +08:00
|
|
|
/// incorporating info about the result values into this state.
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
void CCState::AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
CCAssignFn Fn) {
|
2007-02-28 15:09:40 +08:00
|
|
|
// Determine which register each value should be copied into.
|
2010-07-06 23:39:54 +08:00
|
|
|
for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT VT = Outs[i].VT;
|
2010-07-06 23:39:54 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
|
|
|
|
if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
dbgs() << "Return operand #" << i << " has unhandled type "
|
2012-11-14 13:20:09 +08:00
|
|
|
<< EVT(VT).getEVTString() << '\n';
|
2010-07-06 23:39:54 +08:00
|
|
|
#endif
|
|
|
|
llvm_unreachable(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
/// AnalyzeCallOperands - Analyze the outgoing arguments to a call,
|
|
|
|
/// incorporating info about the passed values into this state.
|
|
|
|
void CCState::AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
CCAssignFn Fn) {
|
|
|
|
unsigned NumOps = Outs.size();
|
2010-07-06 23:39:54 +08:00
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT ArgVT = Outs[i].VT;
|
2010-07-06 23:39:54 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
|
|
|
|
if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
|
|
|
|
#ifndef NDEBUG
|
|
|
|
dbgs() << "Call operand #" << i << " has unhandled type "
|
2012-11-14 13:20:09 +08:00
|
|
|
<< EVT(ArgVT).getEVTString() << '\n';
|
2010-07-06 23:39:54 +08:00
|
|
|
#endif
|
|
|
|
llvm_unreachable(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-06 00:59:26 +08:00
|
|
|
/// AnalyzeCallOperands - Same as above except it takes vectors of types
|
|
|
|
/// and argument flags.
|
2010-11-03 19:35:31 +08:00
|
|
|
void CCState::AnalyzeCallOperands(SmallVectorImpl<MVT> &ArgVTs,
|
2008-09-06 00:59:26 +08:00
|
|
|
SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
|
|
|
|
CCAssignFn Fn) {
|
|
|
|
unsigned NumOps = ArgVTs.size();
|
|
|
|
for (unsigned i = 0; i != NumOps; ++i) {
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT ArgVT = ArgVTs[i];
|
2008-09-06 00:59:26 +08:00
|
|
|
ISD::ArgFlagsTy ArgFlags = Flags[i];
|
|
|
|
if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
|
2009-07-15 00:55:14 +08:00
|
|
|
#ifndef NDEBUG
|
2010-01-05 09:24:50 +08:00
|
|
|
dbgs() << "Call operand #" << i << " has unhandled type "
|
2012-11-14 13:20:09 +08:00
|
|
|
<< EVT(ArgVT).getEVTString() << '\n';
|
2009-07-15 00:55:14 +08:00
|
|
|
#endif
|
|
|
|
llvm_unreachable(0);
|
2008-09-06 00:59:26 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
/// AnalyzeCallResult - Analyze the return values of a call,
|
2007-02-28 15:09:40 +08:00
|
|
|
/// incorporating info about the passed values into this state.
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
void CCState::AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
|
|
|
|
CCAssignFn Fn) {
|
|
|
|
for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
|
2010-11-03 19:35:31 +08:00
|
|
|
MVT VT = Ins[i].VT;
|
Major calling convention code refactoring.
Instead of awkwardly encoding calling-convention information with ISD::CALL,
ISD::FORMAL_ARGUMENTS, ISD::RET, and ISD::ARG_FLAGS nodes, TargetLowering
provides three virtual functions for targets to override:
LowerFormalArguments, LowerCall, and LowerRet, which replace the custom
lowering done on the special nodes. They provide the same information, but
in a more immediately usable format.
This also reworks much of the target-independent tail call logic. The
decision of whether or not to perform a tail call is now cleanly split
between target-independent portions, and the target dependent portion
in IsEligibleForTailCallOptimization.
This also synchronizes all in-tree targets, to help enable future
refactoring and feature work.
llvm-svn: 78142
2009-08-05 09:29:28 +08:00
|
|
|
ISD::ArgFlagsTy Flags = Ins[i].Flags;
|
2008-09-27 03:31:26 +08:00
|
|
|
if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) {
|
2009-07-15 00:55:14 +08:00
|
|
|
#ifndef NDEBUG
|
2010-01-05 09:24:50 +08:00
|
|
|
dbgs() << "Call result #" << i << " has unhandled type "
|
2012-11-14 13:20:09 +08:00
|
|
|
<< EVT(VT).getEVTString() << '\n';
|
2009-07-15 00:55:14 +08:00
|
|
|
#endif
|
|
|
|
llvm_unreachable(0);
|
2007-02-28 14:56:37 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-09-07 17:02:18 +08:00
|
|
|
|
|
|
|
/// AnalyzeCallResult - Same as above except it's specialized for calls which
|
|
|
|
/// produce a single value.
|
2010-11-03 19:35:31 +08:00
|
|
|
void CCState::AnalyzeCallResult(MVT VT, CCAssignFn Fn) {
|
2008-09-07 17:02:18 +08:00
|
|
|
if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) {
|
2009-07-15 00:55:14 +08:00
|
|
|
#ifndef NDEBUG
|
2010-01-05 09:24:50 +08:00
|
|
|
dbgs() << "Call result has unhandled type "
|
2012-11-14 13:20:09 +08:00
|
|
|
<< EVT(VT).getEVTString() << '\n';
|
2009-07-15 00:55:14 +08:00
|
|
|
#endif
|
|
|
|
llvm_unreachable(0);
|
2008-09-07 17:02:18 +08:00
|
|
|
}
|
|
|
|
}
|