1//===-- llvm/CallingConv.h - LLVM Calling Conventions -----------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines LLVM's set of calling conventions.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CALLINGCONV_H
15#define LLVM_CALLINGCONV_H
16
17namespace llvm {
18
19/// CallingConv Namespace - This namespace contains an enum with a value for
20/// the well-known calling conventions.
21///
22namespace CallingConv {
23  /// A set of enums which specify the assigned numeric values for known llvm
24  /// calling conventions.
25  /// @brief LLVM Calling Convention Representation
26  enum ID {
27    /// C - The default llvm calling convention, compatible with C.  This
28    /// convention is the only calling convention that supports varargs calls.
29    /// As with typical C calling conventions, the callee/caller have to
30    /// tolerate certain amounts of prototype mismatch.
31    C = 0,
32
33    // Generic LLVM calling conventions.  None of these calling conventions
34    // support varargs calls, and all assume that the caller and callee
35    // prototype exactly match.
36
37    /// Fast - This calling convention attempts to make calls as fast as
38    /// possible (e.g. by passing things in registers).
39    Fast = 8,
40
41    // Cold - This calling convention attempts to make code in the caller as
42    // efficient as possible under the assumption that the call is not commonly
43    // executed.  As such, these calls often preserve all registers so that the
44    // call does not break any live ranges in the caller side.
45    Cold = 9,
46
47    // GHC - Calling convention used by the Glasgow Haskell Compiler (GHC).
48    GHC = 10,
49
50    // Target - This is the start of the target-specific calling conventions,
51    // e.g. fastcall and thiscall on X86.
52    FirstTargetCC = 64,
53
54    /// X86_StdCall - stdcall is the calling conventions mostly used by the
55    /// Win32 API. It is basically the same as the C convention with the
56    /// difference in that the callee is responsible for popping the arguments
57    /// from the stack.
58    X86_StdCall = 64,
59
60    /// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments
61    /// in ECX:EDX registers, others - via stack. Callee is responsible for
62    /// stack cleaning.
63    X86_FastCall = 65,
64
65    /// ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete,
66    /// but still used on some targets).
67    ARM_APCS = 66,
68
69    /// ARM_AAPCS - ARM Architecture Procedure Calling Standard calling
70    /// convention (aka EABI). Soft float variant.
71    ARM_AAPCS = 67,
72
73    /// ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI.
74    ARM_AAPCS_VFP = 68,
75
76    /// MSP430_INTR - Calling convention used for MSP430 interrupt routines.
77    MSP430_INTR = 69,
78
79    /// X86_ThisCall - Similar to X86_StdCall. Passes first argument in ECX,
80    /// others via stack. Callee is responsible for stack cleaning. MSVC uses
81    /// this by default for methods in its ABI.
82    X86_ThisCall = 70,
83
84    /// PTX_Kernel - Call to a PTX kernel.
85    /// Passes all arguments in parameter space.
86    PTX_Kernel = 71,
87
88    /// PTX_Device - Call to a PTX device function.
89    /// Passes all arguments in register or parameter space.
90    PTX_Device = 72,
91
92    /// MBLAZE_INTR - Calling convention used for MBlaze interrupt routines.
93    MBLAZE_INTR = 73,
94
95    /// MBLAZE_INTR - Calling convention used for MBlaze interrupt support
96    /// routines (i.e. GCC's save_volatiles attribute).
97    MBLAZE_SVOL = 74,
98
99    /// SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
100    /// No lowering or expansion of arguments.
101    /// Structures are passed as a pointer to a struct with the byval attribute.
102    /// Functions can only call SPIR_FUNC and SPIR_KERNEL functions.
103    /// Functions can only have zero or one return values.
104    /// Variable arguments are not allowed, except for printf.
105    /// How arguments/return values are lowered are not specified.
106    /// Functions are only visible to the devices.
107    SPIR_FUNC = 75,
108
109    /// SPIR_KERNEL - Calling convention for SPIR kernel functions.
110    /// Inherits the restrictions of SPIR_FUNC, except
111    /// Cannot have non-void return values.
112    /// Cannot have variable arguments.
113    /// Can also be called by the host.
114    /// Is externally visible.
115    SPIR_KERNEL = 76,
116
117    /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins
118    Intel_OCL_BI = 77
119
120  };
121} // End CallingConv namespace
122
123} // End llvm namespace
124
125#endif
126