diff --git a/llvm/include/llvm/IR/CallingConv.h b/llvm/include/llvm/IR/CallingConv.h
--- a/llvm/include/llvm/IR/CallingConv.h
+++ b/llvm/include/llvm/IR/CallingConv.h
@@ -27,232 +27,215 @@
   /// calling conventions.
   /// LLVM Calling Convention Representation
   enum {
-    /// C - The default llvm calling convention, compatible with C.  This
-    /// convention is the only calling convention that supports varargs calls.
-    /// As with typical C calling conventions, the callee/caller have to
-    /// tolerate certain amounts of prototype mismatch.
+    /// The default llvm calling convention, compatible with C. This convention
+    /// is the only one that supports varargs calls. As with typical C calling
+    /// conventions, the callee/caller have to tolerate certain amounts of
+    /// prototype mismatch.
     C = 0,
 
-    // Generic LLVM calling conventions.  None of these calling conventions
-    // support varargs calls, and all assume that the caller and callee
-    // prototype exactly match.
+    // Generic LLVM calling conventions. None of these 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).
+    /// 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.
+    /// 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).
+    /// Used by the Glasgow Haskell Compiler (GHC).
     GHC = 10,
 
-    /// HiPE - Calling convention used by the High-Performance Erlang Compiler
-    /// (HiPE).
+    /// Used by the High-Performance Erlang Compiler (HiPE).
     HiPE = 11,
 
-    /// WebKit JS - Calling convention for stack based JavaScript calls
+    /// Used for stack based JavaScript calls
     WebKit_JS = 12,
 
-    /// AnyReg - Calling convention for dynamic register based calls (e.g.
-    /// stackmap and patchpoint intrinsics).
+    /// Used for dynamic register based calls (e.g. stackmap and patchpoint
+    /// intrinsics).
     AnyReg = 13,
 
-    /// PreserveMost - Calling convention for runtime calls that preserves most
-    /// registers.
+    /// Used for runtime calls that preserves most registers.
     PreserveMost = 14,
 
-    /// PreserveAll - Calling convention for runtime calls that preserves
-    /// (almost) all registers.
+    /// Used for runtime calls that preserves (almost) all registers.
     PreserveAll = 15,
 
-    /// Swift - Calling convention for Swift.
+    /// Calling convention for Swift.
     Swift = 16,
 
-    /// CXX_FAST_TLS - Calling convention for access functions.
+    /// Used 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.
+    /// 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.
+    /// 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.
+    /// 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.
+    /// 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.
+    /// stdcall is 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,
 
-    /// X86_FastCall - 'fast' analog of X86_StdCall. Passes first two arguments
-    /// in ECX:EDX registers, others - via stack. Callee is responsible for
-    /// stack cleaning.
+    /// 'fast' analog of X86_StdCall. Passes first two arguments in ECX:EDX
+    /// registers, others - via stack. Callee is responsible for stack cleaning.
     X86_FastCall = 65,
 
-    /// ARM_APCS - ARM Procedure Calling Standard calling convention (obsolete,
-    /// but still used on some targets).
+    /// ARM Procedure Calling Standard (obsolete, but still used on some
+    /// targets).
     ARM_APCS = 66,
 
-    /// ARM_AAPCS - ARM Architecture Procedure Calling Standard calling
-    /// convention (aka EABI). Soft float variant.
+    /// ARM Architecture Procedure Calling Standard calling convention (aka
+    /// EABI). Soft float variant.
     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,
 
-    /// MSP430_INTR - Calling convention used for MSP430 interrupt routines.
+    /// Used for MSP430 interrupt routines.
     MSP430_INTR = 69,
 
-    /// X86_ThisCall - Similar to X86_StdCall. Passes first argument in ECX,
-    /// others via stack. Callee is responsible for stack cleaning. MSVC uses
-    /// this by default for methods in its ABI.
+    /// Similar to X86_StdCall. Passes first argument in ECX, others via stack.
+    /// Callee is responsible for stack cleaning. MSVC uses this by default for
+    /// methods in its ABI.
     X86_ThisCall = 70,
 
-    /// PTX_Kernel - Call to a PTX kernel.
-    /// Passes all arguments in parameter space.
+    /// Call to a PTX kernel. Passes all arguments in parameter space.
     PTX_Kernel = 71,
 
-    /// PTX_Device - Call to a PTX device function.
-    /// Passes all arguments in register or parameter space.
+    /// Call to a PTX device function. Passes all arguments in register or
+    /// parameter space.
     PTX_Device = 72,
 
-    /// SPIR_FUNC - Calling convention for SPIR non-kernel device functions.
-    /// No lowering or expansion of arguments.
-    /// Structures are passed as a pointer to a struct with the byval attribute.
-    /// Functions can only call SPIR_FUNC and SPIR_KERNEL functions.
-    /// Functions can only have zero or one return values.
-    /// Variable arguments are not allowed, except for printf.
-    /// How arguments/return values are lowered are not specified.
-    /// Functions are only visible to the devices.
+    /// Used for SPIR non-kernel device functions. No lowering or expansion of
+    /// arguments. Structures are passed as a pointer to a struct with the
+    /// byval attribute. Functions can only call SPIR_FUNC and SPIR_KERNEL
+    /// functions. Functions can only have zero or one return values. Variable
+    /// arguments are not allowed, except for printf. How arguments/return
+    /// values are lowered are not specified. Functions are only visible to the
+    /// devices.
     SPIR_FUNC = 75,
 
-    /// SPIR_KERNEL - Calling convention for SPIR kernel functions.
-    /// Inherits the restrictions of SPIR_FUNC, except
-    /// Cannot have non-void return values.
-    /// Cannot have variable arguments.
-    /// Can also be called by the host.
-    /// Is externally visible.
+    /// Used for SPIR kernel functions. Inherits the restrictions of SPIR_FUNC,
+    /// except it cannot have non-void return values, it cannot have variable
+    /// arguments, it can also be called by the host or it is externally
+    /// visible.
     SPIR_KERNEL = 76,
 
-    /// Intel_OCL_BI - Calling conventions for Intel OpenCL built-ins
+    /// Used for Intel OpenCL built-ins.
     Intel_OCL_BI = 77,
 
-    /// The C convention as specified in the x86-64 supplement to the
-    /// System V ABI, used on most non-Windows systems.
+    /// The C convention as specified in the x86-64 supplement to the System V
+    /// ABI, used on most non-Windows systems.
     X86_64_SysV = 78,
 
-    /// The C convention as implemented on Windows/x86-64 and
-    /// AArch64. This convention differs from the more common
-    /// \c X86_64_SysV convention in a number of ways, most notably in
-    /// that XMM registers used to pass arguments are shadowed by GPRs,
-    /// and vice versa.
-    /// On AArch64, this is identical to the normal C (AAPCS) calling
-    /// convention for normal functions, but floats are passed in integer
-    /// registers to variadic functions.
+    /// The C convention as implemented on Windows/x86-64 and AArch64. It
+    /// differs from the more common \c X86_64_SysV convention in a number of
+    /// ways, most notably in that XMM registers used to pass arguments are
+    /// shadowed by GPRs, and vice versa. On AArch64, this is identical to the
+    /// normal C (AAPCS) calling convention for normal functions, but floats are
+    /// passed in integer registers to variadic functions.
     Win64 = 79,
 
-    /// MSVC calling convention that passes vectors and vector aggregates
-    /// in SSE registers.
+    /// MSVC calling convention that passes vectors and vector aggregates in SSE
+    /// registers.
     X86_VectorCall = 80,
 
-    /// Calling convention used by HipHop Virtual Machine (HHVM) to
-    /// perform calls to and from translation cache, and for calling PHP
-    /// functions.
-    /// HHVM calling convention supports tail/sibling call elimination.
+    /// Used by HipHop Virtual Machine (HHVM) to perform calls to and from
+    /// translation cache, and for calling PHP functions. HHVM calling
+    /// convention supports tail/sibling call elimination.
     HHVM = 81,
 
     /// HHVM calling convention for invoking C/C++ helpers.
     HHVM_C = 82,
 
-    /// X86_INTR - x86 hardware interrupt context. Callee may take one or two
-    /// parameters, where the 1st represents a pointer to hardware context frame
-    /// and the 2nd represents hardware error code, the presence of the later
-    /// depends on the interrupt vector taken. Valid for both 32- and 64-bit
-    /// subtargets.
+    /// x86 hardware interrupt context. Callee may take one or two parameters,
+    /// where the 1st represents a pointer to hardware context frame and the 2nd
+    /// represents hardware error code, the presence of the later depends on the
+    /// interrupt vector taken. Valid for both 32- and 64-bit subtargets.
     X86_INTR = 83,
 
     /// Used for AVR interrupt routines.
     AVR_INTR = 84,
 
-    /// Calling convention used for AVR signal routines.
+    /// Used for AVR signal routines.
     AVR_SIGNAL = 85,
 
-    /// Calling convention used for special AVR rtlib functions
-    /// which have an "optimized" convention to preserve registers.
+    /// Used for special AVR rtlib functions which have an "optimized"
+    /// convention to preserve registers.
     AVR_BUILTIN = 86,
 
-    /// Calling convention used for Mesa vertex shaders, or AMDPAL last shader
-    /// stage before rasterization (vertex shader if tessellation and geometry
-    /// are not in use, or otherwise copy shader if one is needed).
+    /// Used for Mesa vertex shaders, or AMDPAL last shader stage before
+    /// rasterization (vertex shader if tessellation and geometry are not in
+    /// use, or otherwise copy shader if one is needed).
     AMDGPU_VS = 87,
 
-    /// Calling convention used for Mesa/AMDPAL geometry shaders.
+    /// Used for Mesa/AMDPAL geometry shaders.
     AMDGPU_GS = 88,
 
-    /// Calling convention used for Mesa/AMDPAL pixel shaders.
+    /// Used for Mesa/AMDPAL pixel shaders.
     AMDGPU_PS = 89,
 
-    /// Calling convention used for Mesa/AMDPAL compute shaders.
+    /// Used for Mesa/AMDPAL compute shaders.
     AMDGPU_CS = 90,
 
-    /// Calling convention for AMDGPU code object kernels.
+    /// Used for AMDGPU code object kernels.
     AMDGPU_KERNEL = 91,
 
     /// Register calling convention used for parameters transfer optimization
     X86_RegCall = 92,
 
-    /// Calling convention used for Mesa/AMDPAL hull shaders (= tessellation
-    /// control shaders).
+    /// Used for Mesa/AMDPAL hull shaders (= tessellation control shaders).
     AMDGPU_HS = 93,
 
-    /// Calling convention used for special MSP430 rtlib functions
-    /// which have an "optimized" convention using additional registers.
+    /// Used for special MSP430 rtlib functions which have an "optimized"
+    /// convention using additional registers.
     MSP430_BUILTIN = 94,
 
-    /// Calling convention used for AMDPAL vertex shader if tessellation is in
-    /// use.
+    /// Used for AMDPAL vertex shader if tessellation is in 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.
+    /// 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
+    /// Used between AArch64 Advanced SIMD functions
     AArch64_VectorCall = 97,
 
-    /// Calling convention between AArch64 SVE functions
+    /// Used 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.
+    /// For emscripten __invoke_* functions. The first argument is required to
+    /// be the function ptr being indirectly called. The remainder matches the
+    /// regular calling convention.
     WASM_EmscriptenInvoke = 99,
 
-    /// Calling convention used for AMD graphics targets.
+    /// Used for AMD graphics targets.
     AMDGPU_Gfx = 100,
 
-    /// M68k_INTR - Calling convention used for M68k interrupt routines.
+    /// Used for M68k interrupt routines.
     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
   };