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

[Docs] Fix duplicate enum item name 

Removes duplicated names as recommended here: https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments

Reviewed By: MaskRay

Differential Revision: https://reviews.llvm.org/D131193
This commit is contained in:
Marc Auberer 2022-08-11 09:59:08 -07:00 committed by Fangrui Song
parent 4248f32b9e
commit 84b7055afc
1 changed files with 103 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
llvm/include/llvm/IR/CallingConv.h
View File

@ -27,232 +27,215 @@ namespace CallingConv {
/// calling conventions. /// calling conventions.
/// LLVM Calling Convention Representation /// LLVM Calling Convention Representation
enum { enum {
/// C - The default llvm calling convention, compatible with C. This /// The default llvm calling convention, compatible with C. This convention
/// convention is the only calling convention that supports varargs calls. /// is the only one that supports varargs calls. As with typical C calling
/// As with typical C calling conventions, the callee/caller have to /// conventions, the callee/caller have to tolerate certain amounts of
/// tolerate certain amounts of prototype mismatch. /// prototype mismatch.
C = 0, C = 0,
// Generic LLVM calling conventions. None of these calling conventions // Generic LLVM calling conventions. None of these support varargs calls,
// support varargs calls, and all assume that the caller and callee // and all assume that the caller and callee prototype exactly match.
// prototype exactly match.
/// Fast - This calling convention attempts to make calls as fast as /// Attempts to make calls as fast as possible (e.g. by passing things in
/// possible (e.g. by passing things in registers). /// registers).
Fast = 8, Fast = 8,
/// Cold - This calling convention attempts to make code in the caller as /// Attempts to make code in the caller as efficient as possible under the
/// efficient as possible under the assumption that the call is not commonly /// assumption that the call is not commonly executed. As such, these calls
/// executed. As such, these calls often preserve all registers so that the /// often preserve all registers so that the call does not break any live
/// call does not break any live ranges in the caller side. /// ranges in the caller side.
Cold = 9, Cold = 9,
/// GHC - Calling convention used by the Glasgow Haskell Compiler (GHC). /// Used by the Glasgow Haskell Compiler (GHC).
GHC = 10, GHC = 10,
/// HiPE - Calling convention used by the High-Performance Erlang Compiler /// Used by the High-Performance Erlang Compiler (HiPE).
/// (HiPE).
HiPE = 11, HiPE = 11,
/// WebKit JS - Calling convention for stack based JavaScript calls /// Used for stack based JavaScript calls
WebKit_JS = 12, WebKit_JS = 12,
/// AnyReg - Calling convention for dynamic register based calls (e.g. /// Used for dynamic register based calls (e.g. stackmap and patchpoint
/// stackmap and patchpoint intrinsics). /// intrinsics).
AnyReg = 13, AnyReg = 13,
/// PreserveMost - Calling convention for runtime calls that preserves most /// Used for runtime calls that preserves most registers.
/// registers.
PreserveMost = 14, PreserveMost = 14,
/// PreserveAll - Calling convention for runtime calls that preserves /// Used for runtime calls that preserves (almost) all registers.
/// (almost) all registers.
PreserveAll = 15, PreserveAll = 15,
/// Swift - Calling convention for Swift. /// Calling convention for Swift.
Swift = 16, Swift = 16,
/// CXX_FAST_TLS - Calling convention for access functions. /// Used for access functions.
CXX_FAST_TLS = 17, CXX_FAST_TLS = 17,
/// Tail - This calling convention attemps to make calls as fast as /// Attemps to make calls as fast as possible while guaranteeing that tail
/// possible while guaranteeing that tail call optimization can always /// call optimization can always be performed.
/// be performed.
Tail = 18, Tail = 18,
/// Special calling convention on Windows for calling the Control /// Special calling convention on Windows for calling the Control Guard
/// Guard Check ICall funtion. The function takes exactly one argument /// Check ICall funtion. The function takes exactly one argument (address of
/// (address of the target function) passed in the first argument register, /// the target function) passed in the first argument register, and has no
/// and has no return value. All register values are preserved. /// return value. All register values are preserved.
CFGuard_Check = 19, CFGuard_Check = 19,
/// SwiftTail - This follows the Swift calling convention in how arguments /// This follows the Swift calling convention in how arguments are passed
/// are passed but guarantees tail calls will be made by making the callee /// but guarantees tail calls will be made by making the callee clean up
/// clean up their stack. /// their stack.
SwiftTail = 20, SwiftTail = 20,
/// Target - This is the start of the target-specific calling conventions, /// This is the start of the target-specific calling conventions, e.g.
/// e.g. fastcall and thiscall on X86. /// fastcall and thiscall on X86.
FirstTargetCC = 64, FirstTargetCC = 64,
/// X86_StdCall - stdcall is the calling conventions mostly used by the /// stdcall is mostly used by the Win32 API. It is basically the same as the
/// Win32 API. It is basically the same as the C convention with the /// C convention with the difference in that the callee is responsible for
/// difference in that the callee is responsible for popping the arguments /// popping the arguments from the stack.
/// from the stack.
X86_StdCall = 64, X86_StdCall = 64,
/// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments /// 'fast' analog of X86_StdCall. Passes first two arguments in ECX:EDX
/// in ECX:EDX registers, others - via stack. Callee is responsible for /// registers, others - via stack. Callee is responsible for stack cleaning.
/// stack cleaning.
X86_FastCall = 65, X86_FastCall = 65,
/// ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete, /// ARM Procedure Calling Standard (obsolete, but still used on some
/// but still used on some targets). /// targets).
ARM_APCS = 66, ARM_APCS = 66,
/// ARM_AAPCS - ARM Architecture Procedure Calling Standard calling /// ARM Architecture Procedure Calling Standard calling convention (aka
/// convention (aka EABI). Soft float variant. /// EABI). Soft float variant.
ARM_AAPCS = 67, ARM_AAPCS = 67,
/// ARM_AAPCS_VFP - Same as ARM_AAPCS, but uses hard floating point ABI. /// Same as ARM_AAPCS, but uses hard floating point ABI.
ARM_AAPCS_VFP = 68, ARM_AAPCS_VFP = 68,
/// MSP430_INTR - Calling convention used for MSP430 interrupt routines. /// Used for MSP430 interrupt routines.
MSP430_INTR = 69, MSP430_INTR = 69,
/// X86_ThisCall - Similar to X86_StdCall. Passes first argument in ECX, /// Similar to X86_StdCall. Passes first argument in ECX, others via stack.
/// others via stack. Callee is responsible for stack cleaning. MSVC uses /// Callee is responsible for stack cleaning. MSVC uses this by default for
/// this by default for methods in its ABI. /// methods in its ABI.
X86_ThisCall = 70, X86_ThisCall = 70,
/// PTX_Kernel - Call to a PTX kernel. /// Call to a PTX kernel. Passes all arguments in parameter space.
/// Passes all arguments in parameter space.
PTX_Kernel = 71, PTX_Kernel = 71,
/// PTX_Device - Call to a PTX device function. /// Call to a PTX device function. Passes all arguments in register or
/// Passes all arguments in register or parameter space. /// parameter space.
PTX_Device = 72, PTX_Device = 72,
/// SPIR_FUNC - Calling convention for SPIR non-kernel device functions. /// Used for SPIR non-kernel device functions. No lowering or expansion of
/// No lowering or expansion of arguments. /// arguments. Structures are passed as a pointer to a struct with the
/// Structures are passed as a pointer to a struct with the byval attribute. /// byval attribute. Functions can only call SPIR_FUNC and SPIR_KERNEL
/// Functions can only call SPIR_FUNC and SPIR_KERNEL functions. /// functions. Functions can only have zero or one return values. Variable
/// Functions can only have zero or one return values. /// arguments are not allowed, except for printf. How arguments/return
/// Variable arguments are not allowed, except for printf. /// values are lowered are not specified. Functions are only visible to the
/// How arguments/return values are lowered are not specified. /// devices.
/// Functions are only visible to the devices.
SPIR_FUNC = 75, SPIR_FUNC = 75,
/// SPIR_KERNEL - Calling convention for SPIR kernel functions. /// Used for SPIR kernel functions. Inherits the restrictions of SPIR_FUNC,
/// Inherits the restrictions of SPIR_FUNC, except /// except it cannot have non-void return values, it cannot have variable
/// Cannot have non-void return values. /// arguments, it can also be called by the host or it is externally
/// Cannot have variable arguments. /// visible.
/// Can also be called by the host.
/// Is externally visible.
SPIR_KERNEL = 76, SPIR_KERNEL = 76,
/// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins /// Used for Intel OpenCL built-ins.
Intel_OCL_BI = 77, Intel_OCL_BI = 77,
/// The C convention as specified in the x86-64 supplement to the /// The C convention as specified in the x86-64 supplement to the System V
/// System V ABI, used on most non-Windows systems. /// ABI, used on most non-Windows systems.
X86_64_SysV = 78, X86_64_SysV = 78,
/// The C convention as implemented on Windows/x86-64 and /// The C convention as implemented on Windows/x86-64 and AArch64. It
/// AArch64. This convention differs from the more common /// differs from the more common \c X86_64_SysV convention in a number of
/// \c X86_64_SysV convention in a number of ways, most notably in /// ways, most notably in that XMM registers used to pass arguments are
/// that XMM registers used to pass arguments are shadowed by GPRs, /// shadowed by GPRs, and vice versa. On AArch64, this is identical to the
/// and vice versa. /// normal C (AAPCS) calling convention for normal functions, but floats are
/// On AArch64, this is identical to the normal C (AAPCS) calling /// passed in integer registers to variadic functions.
/// convention for normal functions, but floats are passed in integer
/// registers to variadic functions.
Win64 = 79, Win64 = 79,
/// MSVC calling convention that passes vectors and vector aggregates /// MSVC calling convention that passes vectors and vector aggregates in SSE
/// in SSE registers. /// registers.
X86_VectorCall = 80, X86_VectorCall = 80,
/// Calling convention used by HipHop Virtual Machine (HHVM) to /// Used by HipHop Virtual Machine (HHVM) to perform calls to and from
/// perform calls to and from translation cache, and for calling PHP /// translation cache, and for calling PHP functions. HHVM calling
/// functions. /// convention supports tail/sibling call elimination.
/// HHVM calling convention supports tail/sibling call elimination.
HHVM = 81, HHVM = 81,
/// HHVM calling convention for invoking C/C++ helpers. /// HHVM calling convention for invoking C/C++ helpers.
HHVM_C = 82, HHVM_C = 82,
/// X86_INTR - x86 hardware interrupt context. Callee may take one or two /// x86 hardware interrupt context. Callee may take one or two parameters,
/// parameters, where the 1st represents a pointer to hardware context frame /// where the 1st represents a pointer to hardware context frame and the 2nd
/// and the 2nd represents hardware error code, the presence of the later /// represents hardware error code, the presence of the later depends on the
/// depends on the interrupt vector taken. Valid for both 32- and 64-bit /// interrupt vector taken. Valid for both 32- and 64-bit subtargets.
/// subtargets.
X86_INTR = 83, X86_INTR = 83,
/// Used for AVR interrupt routines. /// Used for AVR interrupt routines.
AVR_INTR = 84, AVR_INTR = 84,
/// Calling convention used for AVR signal routines. /// Used for AVR signal routines.
AVR_SIGNAL = 85, AVR_SIGNAL = 85,
/// Calling convention used for special AVR rtlib functions /// Used for special AVR rtlib functions which have an "optimized"
/// which have an "optimized" convention to preserve registers. /// convention to preserve registers.
AVR_BUILTIN = 86, AVR_BUILTIN = 86,
/// Calling convention used for Mesa vertex shaders, or AMDPAL last shader /// Used for Mesa vertex shaders, or AMDPAL last shader stage before
/// stage before rasterization (vertex shader if tessellation and geometry /// rasterization (vertex shader if tessellation and geometry are not in
/// are not in use, or otherwise copy shader if one is needed). /// use, or otherwise copy shader if one is needed).
AMDGPU_VS = 87, AMDGPU_VS = 87,
/// Calling convention used for Mesa/AMDPAL geometry shaders. /// Used for Mesa/AMDPAL geometry shaders.
AMDGPU_GS = 88, AMDGPU_GS = 88,
/// Calling convention used for Mesa/AMDPAL pixel shaders. /// Used for Mesa/AMDPAL pixel shaders.
AMDGPU_PS = 89, AMDGPU_PS = 89,
/// Calling convention used for Mesa/AMDPAL compute shaders. /// Used for Mesa/AMDPAL compute shaders.
AMDGPU_CS = 90, AMDGPU_CS = 90,
/// Calling convention for AMDGPU code object kernels. /// Used for AMDGPU code object kernels.
AMDGPU_KERNEL = 91, AMDGPU_KERNEL = 91,
/// Register calling convention used for parameters transfer optimization /// Register calling convention used for parameters transfer optimization
X86_RegCall = 92, X86_RegCall = 92,
/// Calling convention used for Mesa/AMDPAL hull shaders (= tessellation /// Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
/// control shaders).
AMDGPU_HS = 93, AMDGPU_HS = 93,
/// Calling convention used for special MSP430 rtlib functions /// Used for special MSP430 rtlib functions which have an "optimized"
/// which have an "optimized" convention using additional registers. /// convention using additional registers.
MSP430_BUILTIN = 94, MSP430_BUILTIN = 94,
/// Calling convention used for AMDPAL vertex shader if tessellation is in /// Used for AMDPAL vertex shader if tessellation is in use.
/// use.
AMDGPU_LS = 95, AMDGPU_LS = 95,
/// Calling convention used for AMDPAL shader stage before geometry shader /// Used for AMDPAL shader stage before geometry shader if geometry is in
/// if geometry is in use. So either the domain (= tessellation evaluation) /// use. So either the domain (= tessellation evaluation) shader if
/// shader if tessellation is in use, or otherwise the vertex shader. /// tessellation is in use, or otherwise the vertex shader.
AMDGPU_ES = 96, AMDGPU_ES = 96,
/// Calling convention between AArch64 Advanced SIMD functions /// Used between AArch64 Advanced SIMD functions
AArch64_VectorCall = 97, AArch64_VectorCall = 97,
/// Calling convention between AArch64 SVE functions /// Used between AArch64 SVE functions
AArch64_SVE_VectorCall = 98, AArch64_SVE_VectorCall = 98,
/// Calling convention for emscripten __invoke_* functions. The first /// For emscripten __invoke_* functions. The first argument is required to
/// argument is required to be the function ptr being indirectly called. /// be the function ptr being indirectly called. The remainder matches the
/// The remainder matches the regular calling convention. /// regular calling convention.
WASM_EmscriptenInvoke = 99, WASM_EmscriptenInvoke = 99,
/// Calling convention used for AMD graphics targets. /// Used for AMD graphics targets.
AMDGPU_Gfx = 100, AMDGPU_Gfx = 100,
/// M68k_INTR - Calling convention used for M68k interrupt routines. /// Used for M68k interrupt routines.
M68k_INTR = 101, M68k_INTR = 101,
/// The highest possible calling convention ID. Must be some 2^k - 1. /// The highest possible ID. Must be some 2^k - 1.
MaxID = 1023 MaxID = 1023
}; };