[Docs] Fix missing docs strings for CallingConv.h

[marcauberer]

Summary

Replaces

//

with

///

for some code lines to make it visible in the auto-generated documentation.

[dblaikie]

Sounds great - thanks!

[marcauberer]

Can you submit the change for me? I have no permissions for that.

[MaskRay]

You can do "Don’t duplicate function or class name at the beginning of the comment." from https://llvm.org/docs/CodingStandards.html#commenting while updating the comments.

[marcauberer]

@MaskRay okay, too late. I'm gonna open a new change for this ...

[marcauberer]

@MaskRay here it is: https://reviews.llvm.org/D131193

llvm/include/llvm/IR/CallingConv.h

enum {
     // Generic LLVM calling conventions.  None of these calling conventions
     // support varargs calls, and all assume that the caller and callee
     // prototype exactly match.
 
     /// Fast - This calling convention attempts to make calls as fast as
     /// possible (e.g. by passing things in registers).
     Fast = 8,
 
-    // Cold - This calling convention attempts to make code in the caller as
-    // efficient as possible under the assumption that the call is not commonly
-    // executed.  As such, these calls often preserve all registers so that the
-    // call does not break any live ranges in the caller side.
+    /// Cold - This calling convention attempts to make code in the caller as
+    /// efficient as possible under the assumption that the call is not commonly
+    /// executed.  As such, these calls often preserve all registers so that the
+    /// call does not break any live ranges in the caller side.
     Cold = 9,
 
-    // GHC - Calling convention used by the Glasgow Haskell Compiler (GHC).
+    /// GHC - Calling convention used by the Glasgow Haskell Compiler (GHC).
     GHC = 10,
 
-    // HiPE - Calling convention used by the High-Performance Erlang Compiler
-    // (HiPE).
+    /// HiPE - Calling convention used by the High-Performance Erlang Compiler
+    /// (HiPE).
     HiPE = 11,
 
-    // WebKit JS - Calling convention for stack based JavaScript calls
+    /// WebKit JS - Calling convention for stack based JavaScript calls
     WebKit_JS = 12,
 
-    // AnyReg - Calling convention for dynamic register based calls (e.g.
-    // stackmap and patchpoint intrinsics).
+    /// AnyReg - Calling convention for dynamic register based calls (e.g.
+    /// stackmap and patchpoint intrinsics).
     AnyReg = 13,
 
-    // PreserveMost - Calling convention for runtime calls that preserves most
-    // registers.
+    /// PreserveMost - Calling convention for runtime calls that preserves most
+    /// registers.
     PreserveMost = 14,
 
-    // PreserveAll - Calling convention for runtime calls that preserves
-    // (almost) all registers.
+    /// PreserveAll - Calling convention for runtime calls that preserves
+    /// (almost) all registers.
     PreserveAll = 15,
 
-    // Swift - Calling convention for Swift.
+    /// Swift - Calling convention for Swift.
     Swift = 16,
 
-    // CXX_FAST_TLS - Calling convention for access functions.
+    /// CXX_FAST_TLS - Calling convention for access functions.
     CXX_FAST_TLS = 17,
 
     /// Tail - This calling convention attemps to make calls as fast as
     /// possible while guaranteeing that tail call optimization can always
     /// be performed.
     Tail = 18,
 
     /// Special calling convention on Windows for calling the Control
     /// Guard Check ICall funtion. The function takes exactly one argument
     /// (address of the target function) passed in the first argument register,
     /// and has no return value. All register values are preserved.
     CFGuard_Check = 19,
 
     /// SwiftTail - This follows the Swift calling convention in how arguments
     /// are passed but guarantees tail calls will be made by making the callee
     /// clean up their stack.
     SwiftTail = 20,
 
-    // Target - This is the start of the target-specific calling conventions,
-    // e.g. fastcall and thiscall on X86.
+    /// Target - This is the start of the target-specific calling conventions,
+    /// e.g. fastcall and thiscall on X86.
     FirstTargetCC = 64,
 
     /// X86_StdCall - stdcall is the calling conventions mostly used by the
     /// Win32 API. It is basically the same as the C convention with the
     /// difference in that the callee is responsible for popping the arguments
     /// from the stack.
     X86_StdCall = 64,
 
enum {
     /// use.
     AMDGPU_LS = 95,
 
     /// Calling convention used for AMDPAL shader stage before geometry shader
     /// if geometry is in use. So either the domain (= tessellation evaluation)
     /// shader if tessellation is in use, or otherwise the vertex shader.
     AMDGPU_ES = 96,
 
-    // Calling convention between AArch64 Advanced SIMD functions
+    /// Calling convention between AArch64 Advanced SIMD functions
     AArch64_VectorCall = 97,
 
     /// Calling convention between AArch64 SVE functions
     AArch64_SVE_VectorCall = 98,
 
     /// Calling convention for emscripten __invoke_* functions. The first
     /// argument is required to be the function ptr being indirectly called.
     /// The remainder matches the regular calling convention.