Counter Strike : Global Offensive Source Code
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

121 lines
4.5 KiB

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