Merge llvm/main into amd-debug

Author: SC llvm team

clang/include/clang/Basic/Builtins.td

@@ -5006,6 +5006,12 @@ def HLSLResourceGetStride : LangBuiltin<"HLSL_LANG"> {
   let Prototype = "void(__hlsl_resource_t, uint32_t&)";
 }
 
+def HLSLResourceNonUniformIndex : LangBuiltin<"HLSL_LANG"> {
+  let Spellings = ["__builtin_hlsl_resource_nonuniformindex"];
+  let Attributes = [NoThrow];
+  let Prototype = "uint32_t(uint32_t)";
+}
+
 def HLSLAll : LangBuiltin<"HLSL_LANG"> {
   let Spellings = ["__builtin_hlsl_all"];
   let Attributes = [NoThrow, Const];

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -2298,14 +2298,20 @@ mlir::Value ScalarExprEmitter::VisitRealImag(const UnaryOperator *e,
   }
 
   if (e->getOpcode() == UO_Real) {
+<<<<<<< HEAD
     mlir::Value operand = promotionTy.isNull()
                               ? Visit(op)
                               : cgf.emitPromotedScalarExpr(op, promotionTy);
     return builder.createComplexReal(loc, operand);
+=======
+    return promotionTy.isNull() ? Visit(op)
+                                : cgf.emitPromotedScalarExpr(op, promotionTy);
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
   }
 
   // __imag on a scalar returns zero. Emit the subexpr to ensure side
   // effects are evaluated, but not the actual value.
+<<<<<<< HEAD
   mlir::Value operand;
   if (op->isGLValue()) {
     operand = cgf.emitLValue(op).getPointer();
@@ -2316,6 +2322,18 @@ mlir::Value ScalarExprEmitter::VisitRealImag(const UnaryOperator *e,
     operand = cgf.emitScalarExpr(op);
   }
   return builder.createComplexImag(loc, operand);
+=======
+  if (op->isGLValue())
+    cgf.emitLValue(op);
+  else if (!promotionTy.isNull())
+    cgf.emitPromotedScalarExpr(op, promotionTy);
+  else
+    cgf.emitScalarExpr(op);
+
+  mlir::Type valueTy =
+      cgf.convertType(promotionTy.isNull() ? e->getType() : promotionTy);
+  return builder.getNullValue(valueTy, loc);
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 }
 
 /// Return the size or alignment of the type of argument of the sizeof

clang/lib/CodeGen/CGHLSLBuiltins.cpp

@@ -475,6 +475,7 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID,
     SmallVector<Value *> Args{OrderID, SpaceOp, RangeOp, IndexOp, Name};
     return Builder.CreateIntrinsic(HandleTy, IntrinsicID, Args);
   }
+<<<<<<< HEAD
   case Builtin::BI__builtin_hlsl_resource_counterhandlefromimplicitbinding: {
     Value *MainHandle = EmitScalarExpr(E->getArg(0));
     if (!CGM.getTriple().isSPIRV())
@@ -488,13 +489,16 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID,
     SmallVector<Value *> Args{MainHandle, OrderID, SpaceOp};
     return Builder.CreateIntrinsic(HandleTy, IntrinsicID, Args);
   }
+=======
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
   case Builtin::BI__builtin_hlsl_resource_nonuniformindex: {
     Value *IndexOp = EmitScalarExpr(E->getArg(0));
     llvm::Type *RetTy = ConvertType(E->getType());
     return Builder.CreateIntrinsic(
         RetTy, CGM.getHLSLRuntime().getNonUniformResourceIndexIntrinsic(),
         ArrayRef<Value *>{IndexOp});
   }
+<<<<<<< HEAD
   case Builtin::BI__builtin_hlsl_resource_getdimensions_x: {
     Value *Handle = EmitScalarExpr(E->getArg(0));
     LValue Dim = EmitLValue(E->getArg(1));
@@ -508,6 +512,8 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID,
     LValue Stride = EmitLValue(E->getArg(1));
     return emitBufferStride(this, E->getArg(0), Stride);
   }
+=======
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
   case Builtin::BI__builtin_hlsl_all: {
     Value *Op0 = EmitScalarExpr(E->getArg(0));
     return Builder.CreateIntrinsic(

clang/test/CIR/CodeGen/complex.cpp

@@ -1094,6 +1094,7 @@ void imag_on_non_glvalue() {
 // OGCG: %[[A_IMAG:.*]] = load float, ptr %[[A_IMAG_PTR]], align 4
 // OGCG: store float %[[A_IMAG]], ptr %[[B_ADDR]], align 4
 
+<<<<<<< HEAD
 void atomic_complex_type() {
   _Atomic(float _Complex) a;
   float _Complex b = __c11_atomic_load(&a, __ATOMIC_RELAXED);
@@ -1132,6 +1133,8 @@ void atomic_complex_type() {
 // OGCG: store float %[[ATOMIC_TMP_REAL]], ptr %[[B_REAL_PTR]], align 4
 // OGCG: store float %[[ATOMIC_TMP_IMAG]], ptr %[[B_IMAG_PTR]], align 4
 
+=======
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 void real_on_scalar_glvalue() {
   float a;
   float b = __real__ a;
@@ -1140,8 +1143,12 @@ void real_on_scalar_glvalue() {
 // CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
 // CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
 // CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
+<<<<<<< HEAD
 // CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A]] : !cir.float -> !cir.float
 // CIR: cir.store{{.*}} %[[A_REAL]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+=======
+// CIR: cir.store{{.*}} %[[TMP_A]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 
 // LLVM: %[[A_ADDR:.*]] = alloca float, i64 1, align 4
 // LLVM: %[[B_ADDR:.*]] = alloca float, i64 1, align 4
@@ -1160,9 +1167,14 @@ void imag_on_scalar_glvalue() {
 
 // CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
 // CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
+<<<<<<< HEAD
 // CIR: %[[TMP_A:.*]] = cir.load %[[A_ADDR]] : !cir.ptr<!cir.float>, !cir.float
 // CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.float -> !cir.float
 // CIR: cir.store{{.*}} %[[A_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+=======
+// CIR: %[[CONST_ZERO:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
+// CIR: cir.store{{.*}} %[[CONST_ZERO]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 
 // LLVM: %[[A_ADDR:.*]] = alloca float, i64 1, align 4
 // LLVM: %[[B_ADDR:.*]] = alloca float, i64 1, align 4
@@ -1180,9 +1192,14 @@ void real_on_scalar_with_type_promotion() {
 // CIR: %[[A_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["a"]
 // CIR: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
 // CIR: %[[TMP_A:.*]] = cir.load{{.*}} %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
+<<<<<<< HEAD
 // CIR: %[[TMP_A_F32:.*]] = cir.cast floating %[[TMP_A]] : !cir.f16 -> !cir.float
 // CIR: %[[A_REAL:.*]] = cir.complex.real %[[TMP_A_F32]] : !cir.float -> !cir.float
 // CIR: %[[TMP_A_F16:.*]] = cir.cast floating %[[A_REAL]] : !cir.float -> !cir.f16
+=======
+// CIR: %[[TMP_A_F32:.*]] = cir.cast(floating, %[[TMP_A]] : !cir.f16), !cir.float
+// CIR: %[[TMP_A_F16:.*]] = cir.cast(floating, %[[TMP_A_F32]] : !cir.float), !cir.f16
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 // CIR: cir.store{{.*}} %[[TMP_A_F16]], %[[B_ADDR]] : !cir.f16, !cir.ptr<!cir.f16>
 
 // LLVM: %[[A_ADDR:.*]] = alloca half, i64 1, align 2
@@ -1206,10 +1223,16 @@ void imag_on_scalar_with_type_promotion() {
 
 // CIR: %[[A_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["a"]
 // CIR: %[[B_ADDR:.*]] = cir.alloca !cir.f16, !cir.ptr<!cir.f16>, ["b", init]
+<<<<<<< HEAD
 // CIR: %[[TMP_A:.*]] = cir.load %[[A_ADDR]] : !cir.ptr<!cir.f16>, !cir.f16
 // CIR: %[[A_IMAG:.*]] = cir.complex.imag %[[TMP_A]] : !cir.f16 -> !cir.f16
 // CIR: %[[A_IMAG_F16:.*]] = cir.cast floating %[[A_IMAG]] : !cir.f16 -> !cir.f16
 // CIR: cir.store{{.*}} %[[A_IMAG_F16]], %[[B_ADDR]] : !cir.f16, !cir.ptr<!cir.f16>
+=======
+// CIR: %[[CONST_ZERO:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
+// CIR: %[[CONST_ZERO_F16:.*]] = cir.cast(floating, %[[CONST_ZERO]] : !cir.float), !cir.f16
+// CIR: cir.store{{.*}} %[[CONST_ZERO_F16]], %[[B_ADDR]] : !cir.f16, !cir.ptr<!cir.f16>
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 
 // LLVM: %[[A_ADDR:.*]] = alloca half, i64 1, align 2
 // LLVM: %[[B_ADDR:.*]] = alloca half, i64 1, align 2
@@ -1227,8 +1250,13 @@ void imag_on_const_scalar() {
 // CIR: %[[A_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["a"]
 // CIR: %[[B_ADDR:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["b", init]
 // CIR: %[[CONST_ONE:.*]] = cir.const #cir.fp<1.000000e+00> : !cir.float
+<<<<<<< HEAD
 // CIR: %[[CONST_IMAG:.*]] = cir.complex.imag %[[CONST_ONE]] : !cir.float -> !cir.float
 // CIR: cir.store{{.*}} %[[CONST_IMAG]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+=======
+// CIR: %[[CONST_ZERO:.*]] = cir.const #cir.fp<0.000000e+00> : !cir.float
+// CIR: cir.store{{.*}} %[[CONST_ZERO]], %[[B_ADDR]] : !cir.float, !cir.ptr<!cir.float>
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 
 // LLVM: %[[A_ADDR:.*]] = alloca float, i64 1, align 4
 // LLVM: %[[B_ADDR:.*]] = alloca float, i64 1, align 4
@@ -1237,6 +1265,7 @@ void imag_on_const_scalar() {
 // OGCG: %[[A_ADDR:.*]] = alloca float, align 4
 // OGCG: %[[B_ADDR:.*]] = alloca float, align 4
 // OGCG: store float 0.000000e+00, ptr %[[B_ADDR]], align 4
+<<<<<<< HEAD
 
 void real_on_scalar_from_real_with_type_promotion() {
   _Float16 _Complex a;
@@ -1677,3 +1706,5 @@ void load_store_volatile_2() {
 // OGCG: %[[DV_IMAG_PTR:.*]] = getelementptr inbounds nuw { i32, i32 }, ptr %[[DV_ADDR]], i32 0, i32 1
 // OGCG: store volatile i32 %[[D_REAL]], ptr %[[DV_REAL_PTR]], align 4
 // OGCG: store volatile i32 %[[D_IMAG]], ptr %[[DV_IMAG_PTR]], align 4
+=======
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)

clang/test/Preprocessor/print-header-json.c

@@ -22,7 +22,10 @@
 #include "system2.h"
 
 // RUN: rm %t.txt
+<<<<<<< HEAD
 // RUN: rm -rf %t
+=======
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 // RUN: env CC_PRINT_HEADERS_FORMAT=json CC_PRINT_HEADERS_FILTERING=direct-per-file CC_PRINT_HEADERS_FILE=%t.txt %clang -fsyntax-only -I %S/Inputs/print-header-json -isystem %S/Inputs/print-header-json/system -fmodules -fimplicit-module-maps -fmodules-cache-path=%t %s -o /dev/null
 // RUN: cat %t.txt | FileCheck %s --check-prefix=SUPPORTED_PERFILE_MODULES
 

libcxx/utils/compare-benchmarks

@@ -47,6 +47,7 @@ def parse_lnt(lines, aggregate=statistics.median):
         if benchmark not in results:
             results[benchmark] = {'benchmark': benchmark}
 
+<<<<<<< HEAD
         entry = results[benchmark]
         if metric not in entry:
             entry[metric] = []
@@ -60,9 +61,27 @@ def parse_lnt(lines, aggregate=statistics.median):
     return list(results.values())
 
 def plain_text_comparison(data, metric, baseline_name=None, candidate_name=None):
+=======
+def plain_text_comparison(benchmarks, baseline, candidate, baseline_name=None, candidate_name=None):
+    """
+    Create a tabulated comparison of the baseline and the candidate.
+    """
+    headers = ['Benchmark', baseline_name, candidate_name, 'Difference', '% Difference']
+    fmt = (None, '.2f', '.2f', '.2f', '.2f')
+    table = []
+    for (bm, base, cand) in zip(benchmarks, baseline, candidate):
+        diff = (cand - base) if base and cand else None
+        percent = 100 * (diff / base) if base and cand else None
+        row = [bm, base, cand, diff, percent]
+        table.append(row)
+    return tabulate.tabulate(table, headers=headers, floatfmt=fmt, numalign='right')
+
+def create_chart(benchmarks, baseline, candidate, subtitle=None, baseline_name=None, candidate_name=None):
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     """
     Create a tabulated comparison of the baseline and the candidate for the given metric.
     """
+<<<<<<< HEAD
     data = data.replace(numpy.nan, None) # avoid NaNs in tabulate output
     headers = ['Benchmark', baseline_name, candidate_name, 'Difference', '% Difference']
     fmt = (None, '.2f', '.2f', '.2f', '.2%')
@@ -84,6 +103,16 @@ def create_chart(data, metric, subtitle=None, series_names=None):
     title = ' vs '.join(series_names)
     figure = plotly.express.bar(data, title=title, subtitle=subtitle, x='benchmark', y=series_names, barmode='group')
     figure.update_layout(xaxis_title='', yaxis_title='', legend_title='')
+=======
+    figure = plotly.graph_objects.Figure(layout={
+        'title': {
+            'text': f'{baseline_name} vs {candidate_name}',
+            'subtitle': {'text': subtitle}
+        }
+    })
+    figure.add_trace(plotly.graph_objects.Bar(x=benchmarks, y=baseline, name=baseline_name))
+    figure.add_trace(plotly.graph_objects.Bar(x=benchmarks, y=candidate, name=candidate_name))
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     return figure
 
 def main(argv):
@@ -119,14 +148,22 @@ def main(argv):
     parser.add_argument('--open', action='store_true',
         help='Whether to automatically open the generated HTML file when finished. This option only makes sense '
              'when the output format is `chart`.')
+<<<<<<< HEAD
     parser.add_argument('--series-names', type=str, required=False,
         help='Optional comma-delimited list of names to use for the various series. By default, we use '
              'Baseline and Candidate for two input files, and CandidateN for subsequent inputs.')
+=======
+    parser.add_argument('--baseline-name', type=str, default='Baseline',
+        help='Optional name to use for the "baseline" label.')
+    parser.add_argument('--candidate-name', type=str, default='Candidate',
+        help='Optional name to use for the "candidate" label.')
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     parser.add_argument('--subtitle', type=str, required=False,
         help='Optional subtitle to use for the chart. This can be used to help identify the contents of the chart. '
              'This option cannot be used with the plain text output.')
     args = parser.parse_args(argv)
 
+<<<<<<< HEAD
     # Validate arguments (the values admissible for various arguments depend on other
     # arguments, the number of inputs, etc)
     if args.format == 'text':
@@ -136,6 +173,13 @@ def main(argv):
             parser.error('Passing --subtitle makes no sense with --format=text')
         if args.open:
             parser.error('Passing --open makes no sense with --format=text')
+=======
+    if args.format == 'text' and args.subtitle is not None:
+        parser.error('Passing --subtitle makes no sense with --format=text')
+
+    if args.format == 'text' and args.open:
+        parser.error('Passing --open makes no sense with --format=text')
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
 
     if len(args.files) != 2 and args.sort != 'benchmark':
         parser.error('Using any sort order other than `benchmark` requires exactly two input files.')
@@ -178,13 +222,24 @@ def main(argv):
         data = data.sort_values(by=f'percent')
 
     if args.format == 'chart':
+<<<<<<< HEAD
         figure = create_chart(data, args.metric, subtitle=args.subtitle, series_names=args.series_names)
+=======
+        figure = create_chart(benchmarks, baseline_series, candidate_series, subtitle=args.subtitle,
+                                                                             baseline_name=args.baseline_name,
+                                                                             candidate_name=args.candidate_name)
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
         do_open = args.output is None or args.open
         output = args.output or tempfile.NamedTemporaryFile(suffix='.html').name
         plotly.io.write_html(figure, file=output, auto_open=do_open)
     else:
+<<<<<<< HEAD
         diff = plain_text_comparison(data, args.metric, baseline_name=args.series_names[0],
                                                         candidate_name=args.series_names[1])
+=======
+        diff = plain_text_comparison(benchmarks, baseline_series, candidate_series, baseline_name=args.baseline_name,
+                                                                                    candidate_name=args.candidate_name)
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
         diff += '\n'
         if args.output is not None:
             with open(args.output, 'w') as out:

libcxx/utils/visualize-historical

@@ -112,21 +112,37 @@ def truncate_lines(string, n, marker=None):
     assert len(truncated) <= n, "broken post-condition"
     return '\n'.join(truncated)
 
+<<<<<<< HEAD
 def create_plot(data, metric, trendline=None, subtitle=None):
+=======
+def create_plot(data, metric, subtitle=None):
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     """
     Create a plot object showing the evolution of each benchmark throughout the given commits for
     the given metric.
     """
+<<<<<<< HEAD
     data = data.sort_values(by=['revlist_order', 'benchmark'])
+=======
+    data = data.sort_values(by=['date', 'benchmark'])
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     revlist = pandas.unique(data['commit']) # list of all commits in chronological order
     hover_info = {c: truncate_lines(c.show(), 30, marker='...').replace('\n', '<br>') for c in revlist}
     figure = plotly.express.scatter(data, title=f"{revlist[0].shortrev} to {revlist[-1].shortrev}",
                                           subtitle=subtitle,
+<<<<<<< HEAD
                                           x='revlist_order', y=metric,
                                           symbol='benchmark',
                                           color='benchmark',
                                           hover_name=[hover_info[c] for c in data['commit']],
                                           trendline=trendline)
+=======
+                                          x='date', y=metric,
+                                          symbol='benchmark',
+                                          color='benchmark',
+                                          hover_name=[hover_info[c] for c in data['commit']],
+                                          trendline="lowess")
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     return figure
 
 def directory_path(string):
@@ -213,6 +229,16 @@ def main(argv):
              'Since the chart is interactive, it generally makes most sense to include all the benchmarks '
              'and to then filter them in the browser, but in some cases producing a chart with a reduced '
              'number of data series is useful.')
+<<<<<<< HEAD
+=======
+    parser.add_argument('--find-outliers', metavar='FLOAT', type=float, required=False,
+        help='Instead of building a chart, detect commits that show a large spike (more than the given relative threshold) '
+             'with the previous result and print those to standard output. This can be used to generate a list of '
+             'potential outliers that we might want to re-generate the data for. The threshold is expressed as a '
+             'floating point number, e.g. 0.25 will detect points that differ by more than 25%% from their previous '
+             'result. This option respects --filter, i.e. only benchmarks that match the filter will be analyzed for '
+             'outliers.')
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     parser.add_argument('--subtitle', type=str, required=False,
         help='Optional subtitle for the chart. This can be used to help identify the contents of the chart.')
     parser.add_argument('--git-repo', type=directory_path, default=pathlib.Path(os.getcwd()),
@@ -258,7 +284,11 @@ def main(argv):
             raise RuntimeError(f'Filter "{args.filter}" resulted in empty data set -- nothing to plot')
 
     # Plot the data for all the required benchmarks.
+<<<<<<< HEAD
     figure = create_plot(data, args.metric, trendline=args.trendline, subtitle=args.subtitle)
+=======
+    figure = create_plot(data, args.metric, subtitle=args.subtitle)
+>>>>>>> c9042b8fa9e7 (Merge llvm/main into amd-debug)
     do_open = args.output is None or args.open
     output = args.output if args.output is not None else tempfile.NamedTemporaryFile(suffix='.html').name
     plotly.io.write_html(figure, file=output, auto_open=do_open)