Merge from 'sycl' to 'sycl-web' (intel#19)

.github/CODEOWNERS

@@ -15,14 +15,14 @@ opencl-aot/ @dm-vodopyanov @AlexeySachkov @romanovvlad
 # Device library
 libdevice/ @vzakhari
 
+# DPC++ runtime library
+sycl/ @intel/llvm-reviewers-runtime
+
 # Documentation
 sycl/ReleaseNotes.md @pvchupin
 sycl/doc/ @pvchupin @kbobrovs
 sycl/doc/extensions/ @intel/dpcpp-specification-reviewers
 
-# DPC++ runtime library
-sycl/ @intel/llvm-reviewers-runtime
-
 # USM
 sycl/include/CL/sycl/detail/clusm.hpp @jbrodman
 sycl/include/CL/sycl/detail/usm_impl.hpp @jbrodman

.github/workflows/clang-format.yml

@@ -18,7 +18,7 @@ jobs:
 
     - name: Run clang-format for the patch
       run: |
-        git diff -U0 --no-color ${GITHUB_SHA}^1 ${GITHUB_SHA} -- | ./clang/tools/clang-format/clang-format-diff.py -p1 -binary clang-format-9 > ./clang-format.patch
+        git diff --no-color ${GITHUB_SHA}^1 ${GITHUB_SHA} --name-only -- | grep -v "/test/" | xargs git diff -U0 --no-color ${GITHUB_SHA}^1 ${GITHUB_SHA} -- | ./clang/tools/clang-format/clang-format-diff.py -p1 -binary clang-format-9 > ./clang-format.patch
 
     # Add patch with formatting fixes to CI job artifacts
     - uses: actions/upload-artifact@v1

README.md

@@ -5,11 +5,14 @@
 Intel staging area for llvm.org contribution.
 Home for Intel LLVM-based projects:
 
-* oneAPI Data Parallel C++ compiler - see **sycl** branch. More information on
-   oneAPI and DPC++ is available at
-[https://www.oneapi.com/](https://www.oneapi.com/)
+* oneAPI Data Parallel C++ compiler - see
+  [sycl](https://github.com/intel/llvm/tree/sycl) branch. More information on
+  oneAPI and DPC++ is available at
+  [https://www.oneapi.com/](https://www.oneapi.com/)
   * [![Linux Post Commit Checks](https://github.com/intel/llvm/workflows/Linux%20Post%20Commit%20Checks/badge.svg)](https://github.com/intel/llvm/actions?query=workflow%3A%22Linux+Post+Commit+Checks%22)
     [![Generate Doxygen documentation](https://github.com/intel/llvm/workflows/Generate%20Doxygen%20documentation/badge.svg)](https://github.com/intel/llvm/actions?query=workflow%3A%22Generate+Doxygen+documentation%22)
+* Late-outline OpenMP\* and OpenMP\* Offload - see
+  [openmp](https://github.com/intel/llvm/tree/openmp) branch.
 
 ## License
 
@@ -23,11 +26,12 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 
 * oneAPI Data Parallel C++ compiler - See
   [DPC++ Documentation](https://intel.github.io/llvm-docs/)
+* Late-outline OpenMP\* and OpenMP\* Offload - TBD
 
 ## DPC++ extensions
 
 DPC++ is an open, cross-architecture language built upon the ISO C++ and Khronos
 SYCL\* standards. DPC++ extends these standards with a number of extensions,
 which can be found in [sycl/doc/extensions](sycl/doc/extensions) directory.
 
-\*Other names and brands may be claimed as the property of others.
+*\*Other names and brands may be claimed as the property of others.*

clang/include/clang/Driver/Options.td

@@ -725,7 +725,7 @@ def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Grou
   Flags<[CC1Option]>;
 def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
-def Wno_sycl_strict : Joined<["-"], "Wno-sycl-strict">, Group<W_Group>, HelpText<"Disable warnings which enforce strict SYCL language compatibility.">;
+def Wno_sycl_strict : Flag<["-"], "Wno-sycl-strict">, Group<W_Group>, HelpText<"Disable warnings which enforce strict SYCL language compatibility.">;
 def Wp_COMMA : CommaJoined<["-"], "Wp,">,
   HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,
   MetaVarName<"<arg>">, Group<Preprocessor_Group>;
@@ -2402,6 +2402,10 @@ def fsycl_device_code_split_esimd : Flag<["-"], "fsycl-device-code-split-esimd">
   Flags<[CC1Option, CoreOption]>, HelpText<"Split SYCL and ESIMD kernels into separate modules">;
 def fno_sycl_device_code_split_esimd : Flag<["-"], "fno-sycl-device-code-split-esimd">,
   Flags<[CC1Option, CoreOption]>, HelpText<"Don't split SYCL and ESIMD kernels into separate modules">;
+def fsycl_device_code_lower_esimd : Flag<["-"], "fsycl-device-code-lower-esimd">,
+  Flags<[CC1Option, CoreOption]>, HelpText<"Lower ESIMD-specific constructs">;
+def fno_sycl_device_code_lower_esimd : Flag<["-"], "fno-sycl-device-code-lower-esimd">,
+  Flags<[CC1Option, CoreOption]>, HelpText<"Do not lower ESIMD-specific constructs">;
 defm sycl_id_queries_fit_in_int: OptInFFlag<"sycl-id-queries-fit-in-int", "Assume", "Do not assume", " that SYCL ID queries fit within MAX_INT.", [CC1Option,CoreOption], LangOpts<"SYCLValueFitInMaxInt">>;
 def fsycl_use_bitcode : Flag<["-"], "fsycl-use-bitcode">,
   Flags<[CC1Option, CoreOption]>, HelpText<"Use LLVM bitcode instead of SPIR-V in fat objects">;

clang/include/clang/Sema/Sema.h

@@ -13068,14 +13068,12 @@ void Sema::addIntelSYCLSingleArgFunctionAttr(Decl *D,
   assert(E && "Attribute must have an argument.");
 
   if (!E->isInstantiationDependent()) {
-    Optional<llvm::APSInt> ArgVal = E->getIntegerConstantExpr(getASTContext());
-    if (!ArgVal) {
-      Diag(E->getExprLoc(), diag::err_attribute_argument_type)
-          << CI.getAttrName() << AANT_ArgumentIntegerConstant
-          << E->getSourceRange();
+    llvm::APSInt ArgVal;
+    ExprResult ICE = VerifyIntegerConstantExpression(E, &ArgVal);
+    if (ICE.isInvalid())
       return;
-    }
-    int32_t ArgInt = ArgVal->getSExtValue();
+    E = ICE.get();
+    int32_t ArgInt = ArgVal.getSExtValue();
     if (CI.getParsedKind() == ParsedAttr::AT_SYCLIntelNumSimdWorkItems ||
         CI.getParsedKind() == ParsedAttr::AT_IntelReqdSubGroupSize) {
       if (ArgInt <= 0) {
@@ -13101,77 +13099,59 @@ void Sema::addIntelSYCLSingleArgFunctionAttr(Decl *D,
   D->addAttr(::new (Context) AttrType(Context, CI, E));
 }
 
-template <typename AttrInfo>
-static bool handleMaxWorkSizeAttrExpr(Sema &S, const AttrInfo &AI,
-                                      const Expr *E, unsigned &Val,
-                                      unsigned Idx) {
+static Expr *checkMaxWorkSizeAttrExpr(Sema &S, const AttributeCommonInfo &CI,
+                                      Expr *E) {
   assert(E && "Attribute must have an argument.");
 
   if (!E->isInstantiationDependent()) {
-    Optional<llvm::APSInt> ArgVal =
-        E->getIntegerConstantExpr(S.getASTContext());
+    llvm::APSInt ArgVal;
+    ExprResult ICE = S.VerifyIntegerConstantExpression(E, &ArgVal);
 
-    if (!ArgVal) {
-      S.Diag(AI.getLocation(), diag::err_attribute_argument_type)
-          << &AI << AANT_ArgumentIntegerConstant << E->getSourceRange();
-      return false;
-    }
+    if (ICE.isInvalid())
+      return nullptr;
+
+    E = ICE.get();
 
-    if (ArgVal->isNegative()) {
+    if (ArgVal.isNegative()) {
       S.Diag(E->getExprLoc(),
              diag::warn_attribute_requires_non_negative_integer_argument)
           << E->getType() << S.Context.UnsignedLongLongTy
           << E->getSourceRange();
-      return true;
+      return E;
     }
 
-    Val = ArgVal->getZExtValue();
+    unsigned Val = ArgVal.getZExtValue();
     if (Val == 0) {
       S.Diag(E->getExprLoc(), diag::err_attribute_argument_is_zero)
-          << &AI << E->getSourceRange();
-      return false;
+          << CI << E->getSourceRange();
+      return nullptr;
     }
   }
-  return true;
-}
-
-template <typename AttrType>
-static bool checkMaxWorkSizeAttrArguments(Sema &S, Expr *XDimExpr,
-                                          Expr *YDimExpr, Expr *ZDimExpr,
-                                          const AttrType &Attr) {
-  // Accept template arguments for now as they depend on something else.
-  // We'll get to check them when they eventually get instantiated.
-  if (XDimExpr->isValueDependent() ||
-      (YDimExpr && YDimExpr->isValueDependent()) ||
-      (ZDimExpr && ZDimExpr->isValueDependent()))
-    return false;
-
-  unsigned XDim = 0;
-  if (!handleMaxWorkSizeAttrExpr(S, Attr, XDimExpr, XDim, 0))
-    return true;
-
-  unsigned YDim = 0;
-  if (YDimExpr && !handleMaxWorkSizeAttrExpr(S, Attr, YDimExpr, YDim, 1))
-    return true;
-
-  unsigned ZDim = 0;
-  if (ZDimExpr && !handleMaxWorkSizeAttrExpr(S, Attr, ZDimExpr, ZDim, 2))
-    return true;
-
-  return false;
+  return E;
 }
 
 template <typename WorkGroupAttrType>
 void Sema::addIntelSYCLTripleArgFunctionAttr(Decl *D,
                                              const AttributeCommonInfo &CI,
                                              Expr *XDimExpr, Expr *YDimExpr,
                                              Expr *ZDimExpr) {
-  WorkGroupAttrType TmpAttr(Context, CI, XDimExpr, YDimExpr, ZDimExpr);
 
-  if (checkMaxWorkSizeAttrArguments(*this, XDimExpr, YDimExpr, ZDimExpr,
-                                    TmpAttr))
-    return;
+  assert((XDimExpr && YDimExpr && ZDimExpr) &&
+         "argument has unexpected null value");
+
+  // Accept template arguments for now as they depend on something else.
+  // We'll get to check them when they eventually get instantiated.
+  if (!XDimExpr->isValueDependent() && !YDimExpr->isValueDependent() &&
+      !ZDimExpr->isValueDependent()) {
+
+    // Save ConstantExpr in semantic attribute
+    XDimExpr = checkMaxWorkSizeAttrExpr(*this, CI, XDimExpr);
+    YDimExpr = checkMaxWorkSizeAttrExpr(*this, CI, YDimExpr);
+    ZDimExpr = checkMaxWorkSizeAttrExpr(*this, CI, ZDimExpr);
 
+    if (!XDimExpr || !YDimExpr || !ZDimExpr)
+      return;
+  }
   D->addAttr(::new (Context)
                  WorkGroupAttrType(Context, CI, XDimExpr, YDimExpr, ZDimExpr));
 }

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -620,7 +620,6 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
   }
 
   if (const ReqdWorkGroupSizeAttr *A = FD->getAttr<ReqdWorkGroupSizeAttr>()) {
-    llvm::LLVMContext &Context = getLLVMContext();
     ASTContext &ClangCtx = FD->getASTContext();
     Optional<llvm::APSInt> XDimVal = A->getXDimVal(ClangCtx);
     Optional<llvm::APSInt> YDimVal = A->getYDimVal(ClangCtx);
@@ -643,10 +642,9 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 
   if (const IntelReqdSubGroupSizeAttr *A =
           FD->getAttr<IntelReqdSubGroupSizeAttr>()) {
-    llvm::LLVMContext &Context = getLLVMContext();
-    Optional<llvm::APSInt> ArgVal =
-        A->getValue()->getIntegerConstantExpr(FD->getASTContext());
-    assert(ArgVal.hasValue() && "Not an integer constant expression");
+    const auto *CE = dyn_cast<ConstantExpr>(A->getValue());
+    assert(CE && "Not an integer constant expression");
+    Optional<llvm::APSInt> ArgVal = CE->getResultAsAPSInt();
     llvm::Metadata *AttrMDArgs[] = {llvm::ConstantAsMetadata::get(
         Builder.getInt32(ArgVal->getSExtValue()))};
     Fn->setMetadata("intel_reqd_sub_group_size",
@@ -663,10 +661,9 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 
   if (const SYCLIntelNumSimdWorkItemsAttr *A =
       FD->getAttr<SYCLIntelNumSimdWorkItemsAttr>()) {
-    llvm::LLVMContext &Context = getLLVMContext();
-    Optional<llvm::APSInt> ArgVal =
-        A->getValue()->getIntegerConstantExpr(FD->getASTContext());
-    assert(ArgVal.hasValue() && "Not an integer constant expression");
+    const auto *CE = dyn_cast<ConstantExpr>(A->getValue());
+    assert(CE && "Not an integer constant expression");
+    Optional<llvm::APSInt> ArgVal = CE->getResultAsAPSInt();
     llvm::Metadata *AttrMDArgs[] = {llvm::ConstantAsMetadata::get(
         Builder.getInt32(ArgVal->getSExtValue()))};
     Fn->setMetadata("num_simd_work_items",
@@ -675,9 +672,9 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 
   if (const SYCLIntelSchedulerTargetFmaxMhzAttr *A =
           FD->getAttr<SYCLIntelSchedulerTargetFmaxMhzAttr>()) {
-    Optional<llvm::APSInt> ArgVal =
-        A->getValue()->getIntegerConstantExpr(FD->getASTContext());
-    assert(ArgVal.hasValue() && "Not an integer constant expression");
+    const auto *CE = dyn_cast<ConstantExpr>(A->getValue());
+    assert(CE && "Not an integer constant expression");
+    Optional<llvm::APSInt> ArgVal = CE->getResultAsAPSInt();
     llvm::Metadata *AttrMDArgs[] = {llvm::ConstantAsMetadata::get(
         Builder.getInt32(ArgVal->getSExtValue()))};
     Fn->setMetadata("scheduler_target_fmax_mhz",
@@ -686,10 +683,9 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 
   if (const SYCLIntelMaxGlobalWorkDimAttr *A =
       FD->getAttr<SYCLIntelMaxGlobalWorkDimAttr>()) {
-    llvm::LLVMContext &Context = getLLVMContext();
-    Optional<llvm::APSInt> ArgVal =
-        A->getValue()->getIntegerConstantExpr(FD->getASTContext());
-    assert(ArgVal.hasValue() && "Not an integer constant expression");
+    const auto *CE = dyn_cast<ConstantExpr>(A->getValue());
+    assert(CE && "Not an integer constant expression");
+    Optional<llvm::APSInt> ArgVal = CE->getResultAsAPSInt();
     llvm::Metadata *AttrMDArgs[] = {llvm::ConstantAsMetadata::get(
         Builder.getInt32(ArgVal->getSExtValue()))};
     Fn->setMetadata("max_global_work_dim",
@@ -698,7 +694,6 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
 
   if (const SYCLIntelMaxWorkGroupSizeAttr *A =
           FD->getAttr<SYCLIntelMaxWorkGroupSizeAttr>()) {
-    llvm::LLVMContext &Context = getLLVMContext();
     ASTContext &ClangCtx = FD->getASTContext();
     Optional<llvm::APSInt> XDimVal = A->getXDimVal(ClangCtx);
     Optional<llvm::APSInt> YDimVal = A->getYDimVal(ClangCtx);
@@ -723,9 +718,9 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
           FD->getAttr<SYCLIntelNoGlobalWorkOffsetAttr>()) {
     const Expr *Arg = A->getValue();
     assert(Arg && "Got an unexpected null argument");
-    Optional<llvm::APSInt> ArgVal =
-        Arg->getIntegerConstantExpr(FD->getASTContext());
-    assert(ArgVal.hasValue() && "Not an integer constant expression");
+    const auto *CE = dyn_cast<ConstantExpr>(Arg);
+    assert(CE && "Not an integer constant expression");
+    Optional<llvm::APSInt> ArgVal = CE->getResultAsAPSInt();
     if (ArgVal->getBoolValue())
       Fn->setMetadata("no_global_work_offset", llvm::MDNode::get(Context, {}));
   }

clang/lib/CodeGen/CodeGenModule.cpp

@@ -5049,8 +5049,8 @@ void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
     LT = getFunctionLinkage(GD);
     AS = Aliasee->getType()->getPointerAddressSpace();
   } else {
-    const auto *VarD = cast<VarDecl>(GD.getDecl());
-    AS = ArgInfoAddressSpace(GetGlobalVarAddressSpace(VarD));
+    AS = ArgInfoAddressSpace(
+        GetGlobalVarAddressSpace(dyn_cast<VarDecl>(GD.getDecl())));
     Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), DeclTy->getPointerTo(AS),
                                     /*D=*/nullptr);
     if (const auto *VD = dyn_cast<VarDecl>(GD.getDecl()))

clang/lib/Driver/ToolChains/Clang.cpp

@@ -8308,6 +8308,9 @@ void SYCLPostLink::ConstructJob(Compilation &C, const JobAction &JA,
     if (TCArgs.hasFlag(options::OPT_fsycl_device_code_split_esimd,
                        options::OPT_fno_sycl_device_code_split_esimd, true))
       addArgs(CmdArgs, TCArgs, {"-split-esimd"});
+    if (TCArgs.hasFlag(options::OPT_fsycl_device_code_lower_esimd,
+                       options::OPT_fno_sycl_device_code_lower_esimd, false))
+      addArgs(CmdArgs, TCArgs, {"-lower-esimd"});
   }
   // specialization constants processing is mandatory
   auto *SYCLPostLink = llvm::dyn_cast<SYCLPostLinkJobAction>(&JA);

clang/lib/Sema/SemaExpr.cpp

@@ -16227,7 +16227,8 @@ Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
     if (Result)
       *Result = E->EvaluateKnownConstIntCheckOverflow(Context);
     if (!isa<ConstantExpr>(E))
-      E = ConstantExpr::Create(Context, E);
+      E = Result ? ConstantExpr::Create(Context, E, APValue(*Result))
+                 : ConstantExpr::Create(Context, E);
     return E;
   }
 

clang/test/AST/ast-dump-c-attr.c

@@ -34,8 +34,9 @@ struct [[deprecated]] Test4 {
 // CHECK-NEXT:   FieldDecl{{.*}}Test6
 // CHECK-NEXT:     DeprecatedAttr 0x{{[^ ]*}} <col:5, col:25> "Frobble" ""
 // CHECK-NEXT:   FieldDecl{{.*}}Test7
-// CHECK-NEXT:     Constant{{.*}}'int'
-// CHECK-NEXT:       IntegerLiteral{{.*}}'int' 12
+// CHECK-NEXT:     ConstantExpr{{.*}}'int'
+// CHECK-NEXT:       value: Int 12
+// CHECK-NEXT:         IntegerLiteral{{.*}}'int' 12
 // CHECK-NEXT:     DeprecatedAttr 0x{{[^ ]*}} <col:15> "" ""
 
 struct [[deprecated]] Test8;

clang/test/AST/ast-dump-decl-json.c

@@ -948,6 +948,7 @@ void testParmVarDecl(int TestParmVarDecl);
 // CHECK-NEXT:     "qualType": "int"
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "valueCategory": "rvalue",
+// CHECK-NEXT:    "value": "1",
 // CHECK-NEXT:    "inner": [
 // CHECK-NEXT:     {
 // CHECK-NEXT:      "id": "0x{{.*}}",
@@ -1668,6 +1669,7 @@ void testParmVarDecl(int TestParmVarDecl);
 // CHECK-NEXT:     "qualType": "int"
 // CHECK-NEXT:    },
 // CHECK-NEXT:    "valueCategory": "rvalue",
+// CHECK-NEXT:    "value": "1",
 // CHECK-NEXT:    "inner": [
 // CHECK-NEXT:     {
 // CHECK-NEXT:      "id": "0x{{.*}}",

clang/test/AST/ast-dump-decl.c

@@ -112,7 +112,8 @@ enum testEnumConstantDecl {
 // CHECK:      EnumConstantDecl{{.*}} TestEnumConstantDecl 'int'
 // CHECK:      EnumConstantDecl{{.*}} TestEnumConstantDeclInit 'int'
 // CHECK-NEXT:   ConstantExpr
-// CHECK-NEXT:     IntegerLiteral
+// CHECK-NEXT:     value: Int 1
+// CHECK-NEXT:       IntegerLiteral
 
 struct testIndirectFieldDecl {
   struct {
@@ -160,7 +161,8 @@ struct testFieldDecl {
 // CHECK:      FieldDecl{{.*}} TestFieldDecl 'int'
 // CHECK:      FieldDecl{{.*}} TestFieldDeclWidth 'int'
 // CHECK-NEXT:   ConstantExpr
-// CHECK-NEXT:     IntegerLiteral
+// CHECK-NEXT:     value: Int 1
+// CHECK-NEXT:       IntegerLiteral
 // CHECK-MODULE:      FieldDecl{{.*}} TestFieldDeclPrivate 'int' __module_private__
 
 int TestVarDecl;

clang/test/AST/ast-dump-openmp-distribute-parallel-for-simd.c

@@ -113,6 +113,7 @@ void test_five(int x, int y, int z) {
 // CHECK-NEXT: |   `-OMPDistributeParallelForSimdDirective {{.*}} <line:17:1, col:53>
 // CHECK-NEXT: |     |-OMPCollapseClause {{.*}} <col:42, col:52>
 // CHECK-NEXT: |     | `-ConstantExpr {{.*}} <col:51> 'int'
+// CHECK-NEXT: |     | |-value: Int 1
 // CHECK-NEXT: |     |   `-IntegerLiteral {{.*}} <col:51> 'int' 1
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:18:3, line:20:7>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
@@ -159,6 +160,7 @@ void test_five(int x, int y, int z) {
 // CHECK-NEXT: |   `-OMPDistributeParallelForSimdDirective {{.*}} <line:24:1, col:53>
 // CHECK-NEXT: |     |-OMPCollapseClause {{.*}} <col:42, col:52>
 // CHECK-NEXT: |     | `-ConstantExpr {{.*}} <col:51> 'int'
+// CHECK-NEXT: |     | |-value: Int 2
 // CHECK-NEXT: |     |   `-IntegerLiteral {{.*}} <col:51> 'int' 2
 // CHECK-NEXT: |     `-CapturedStmt {{.*}} <line:25:3, line:27:7>
 // CHECK-NEXT: |       |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow
@@ -206,6 +208,7 @@ void test_five(int x, int y, int z) {
 // CHECK-NEXT:     `-OMPDistributeParallelForSimdDirective {{.*}} <line:31:1, col:53>
 // CHECK-NEXT:       |-OMPCollapseClause {{.*}} <col:42, col:52>
 // CHECK-NEXT:       | `-ConstantExpr {{.*}} <col:51> 'int'
+// CHECK-NEXT:       | |-value: Int 2
 // CHECK-NEXT:       |   `-IntegerLiteral {{.*}} <col:51> 'int' 2
 // CHECK-NEXT:       `-CapturedStmt {{.*}} <line:32:3, line:35:9>
 // CHECK-NEXT:         |-CapturedDecl {{.*}} <<invalid sloc>> <invalid sloc> nothrow