mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 04:29:21 +00:00
flags. This is needed by the new legalize types infrastructure which wants to expand the 64 bit constants previously used to hold the flags on 32 bit machines. There are two functional changes: (1) in LowerArguments, if a parameter has the zext attribute set then that is marked in the flags; before it was being ignored; (2) PPC had some bogus code for handling two word arguments when using the ELF 32 ABI, which was hard to convert because of the bogusness. As suggested by the original author (Nicolas Geoffray), I've disabled it for the moment. Tested with "make check" and the Ada ACATS testsuite. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@48640 91177308-0d34-0410-b5e6-96231b3b80d8
96 lines
3.4 KiB
TableGen
96 lines
3.4 KiB
TableGen
//===- TargetCallingConv.td - Target Calling Conventions ---*- tablegen -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the target-independent interfaces with which targets
|
|
// describe their calling conventions.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class CCAction;
|
|
class CallingConv;
|
|
|
|
/// CCPredicateAction - Instances of this class check some predicate, then
|
|
/// delegate to another action if the predicate is true.
|
|
class CCPredicateAction<CCAction A> : CCAction {
|
|
CCAction SubAction = A;
|
|
}
|
|
|
|
/// CCIfType - If the current argument is one of the specified types, apply
|
|
/// Action A.
|
|
class CCIfType<list<ValueType> vts, CCAction A> : CCPredicateAction<A> {
|
|
list<ValueType> VTs = vts;
|
|
}
|
|
|
|
/// CCIf - If the predicate matches, apply A.
|
|
class CCIf<string predicate, CCAction A> : CCPredicateAction<A> {
|
|
string Predicate = predicate;
|
|
}
|
|
|
|
/// CCIfByVal - If the current argument has ByVal parameter attribute, apply
|
|
/// Action A.
|
|
class CCIfByVal<CCAction A> : CCIf<"ArgFlags.isByVal()", A> {
|
|
}
|
|
|
|
/// CCIfCC - Match of the current calling convention is 'CC'.
|
|
class CCIfCC<string CC, CCAction A>
|
|
: CCIf<!strconcat("State.getCallingConv() == ", CC), A> {}
|
|
|
|
/// CCIfInReg - If this argument is marked with the 'inreg' attribute, apply
|
|
/// the specified action.
|
|
class CCIfInReg<CCAction A> : CCIf<"ArgFlags.isInReg()", A> {}
|
|
|
|
/// CCIfNest - If this argument is marked with the 'nest' attribute, apply
|
|
/// the specified action.
|
|
class CCIfNest<CCAction A> : CCIf<"ArgFlags.isNest()", A> {}
|
|
|
|
/// CCIfNotVarArg - If the current function is not vararg - apply the action
|
|
class CCIfNotVarArg<CCAction A> : CCIf<"!State.isVarArg()", A> {}
|
|
|
|
/// CCAssignToReg - This action matches if there is a register in the specified
|
|
/// list that is still available. If so, it assigns the value to the first
|
|
/// available register and succeeds.
|
|
class CCAssignToReg<list<Register> regList> : CCAction {
|
|
list<Register> RegList = regList;
|
|
}
|
|
|
|
/// CCAssignToStack - This action always matches: it assigns the value to a
|
|
/// stack slot of the specified size and alignment on the stack. If size is
|
|
/// zero then the ABI size is used; if align is zero then the ABI alignment
|
|
/// is used - these may depend on the target or subtarget.
|
|
class CCAssignToStack<int size, int align> : CCAction {
|
|
int Size = size;
|
|
int Align = align;
|
|
}
|
|
|
|
/// CCPassByVal - This action always matches: it assigns the value to a stack
|
|
/// slot to implement ByVal aggregate parameter passing. Size and alignment
|
|
/// specify the minimum size and alignment for the stack slot.
|
|
class CCPassByVal<int size, int align> : CCAction {
|
|
int Size = size;
|
|
int Align = align;
|
|
}
|
|
|
|
/// CCPromoteToType - If applied, this promotes the specified current value to
|
|
/// the specified type.
|
|
class CCPromoteToType<ValueType destTy> : CCAction {
|
|
ValueType DestTy = destTy;
|
|
}
|
|
|
|
/// CCDelegateTo - This action invokes the specified sub-calling-convention. It
|
|
/// is successful if the specified CC matches.
|
|
class CCDelegateTo<CallingConv cc> : CCAction {
|
|
CallingConv CC = cc;
|
|
}
|
|
|
|
/// CallingConv - An instance of this is used to define each calling convention
|
|
/// that the target supports.
|
|
class CallingConv<list<CCAction> actions> {
|
|
list<CCAction> Actions = actions;
|
|
}
|