[PowerPC] Implement cmplxl builtins

[Conanap]

Summary

This patch implements the builtins for cmplxl by utilising
__builtin_complex. This builtin is implemented to match XL
functionality.

[nemanjai]

clang/include/clang/Basic/BuiltinsPPC.def

146

Please remove this. The preprocessor will replace this and the builtin call will never make it to the front end.

clang/lib/Basic/Targets/PPC.cpp

238

I don't see a compelling reason to have this. Users that want this functionality in new code (that doesn't already use __cmplxl) can simply use __builtin_complex.

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

45

We really only need this test case and we should be able to just add it to one of the existing XL-compat clang test cases.

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-complex-32bit-only.ll

1

I don't think we need the back end tests. No new IR is produced in this patch.

[NeHuang]

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

1

// REQUIRES: powerpc-registered-target

1

Question: why do we need -O2 for this builtin?

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-complex-32bit-only.ll

1

+1

[amyk]

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

35

I think it would probably be better not to hardcode the variable names in the tests.

[Conanap]

Removed backend tests, removed some uneeded definitions,
updated frontend test with regex for variable names.

[Conanap]

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

1

it's not required, but removes a lot of the extra load and stores that make the test cases longer unnecessarily. I can change it to O1 if preferred.

[NeHuang]

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

45

As suggest above, can we add the test case __cmplxl to one of the existing clang test file builtins-ppc-xlcompat-cmplx.c? You can auto generate the CHECKS using utils/update_cc_test_checks.py to avoid hardcoding the variable names.

[nemanjai]

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

1

I prefer that front end tests should test what the front end does. The front end does not perform optimizations, the optimizer does. So the front end tests should not include optimization options (even though I do realize that adding -O<N> reduces the size of the produced code).
There is no need to add unnecessary churn in front end tests if the optimizer changes.

[Conanap]

Merged the test case into the existing cmplx test

[Conanap]

Removed unintended change

[nemanjai]

LGTM.

[NeHuang]

LGTM

clang/include/clang/Basic/BuiltinsPPC.def

 BUILTIN(__builtin_ppc_dcbtstt, "vv*", "")
 BUILTIN(__builtin_ppc_dcbtt, "vv*", "")
 BUILTIN(__builtin_ppc_mftbu, "Ui","")
 BUILTIN(__builtin_ppc_mfmsr, "Ui", "")
 BUILTIN(__builtin_ppc_mfspr, "ULiIi", "")
 BUILTIN(__builtin_ppc_mtmsr, "vUi", "")
 BUILTIN(__builtin_ppc_mtspr, "vIiULi", "")
 BUILTIN(__builtin_ppc_stfiw, "viC*d", "")
+BUILTIN(__builtin_ppc_cmplxl, "XLdLdLd", "")
 
 BUILTIN(__builtin_ppc_get_timebase, "ULLi", "n")
 
 // This is just a placeholder, the types and attributes are wrong.
 BUILTIN(__builtin_altivec_vaddcuw, "V4UiV4UiV4Ui", "")
 
 BUILTIN(__builtin_altivec_vaddsbs, "V16ScV16ScV16Sc", "")
 BUILTIN(__builtin_altivec_vaddubs, "V16UcV16UcV16Uc", "")

clang/lib/Basic/Targets/PPC.cpp

static void defineXLCompatMacros(MacroBuilder &Builder) {
   Builder.defineMacro("__friz", "__builtin_ppc_friz");
   Builder.defineMacro("__frizs", "__builtin_ppc_frizs");
   Builder.defineMacro("__fsel", "__builtin_ppc_fsel");
   Builder.defineMacro("__fsels", "__builtin_ppc_fsels");
   Builder.defineMacro("__frsqrte", "__builtin_ppc_frsqrte");
   Builder.defineMacro("__frsqrtes", "__builtin_ppc_frsqrtes");
   Builder.defineMacro("__fsqrt", "__builtin_ppc_fsqrt");
   Builder.defineMacro("__fsqrts", "__builtin_ppc_fsqrts");
+  Builder.defineMacro("__builtin_ppc_cmplxl", "__builtin_complex");
+  Builder.defineMacro("__cmplxl", "__builtin_complex");
 }
 
 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
 /// #defines that are not tied to a specific subtarget.
 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
 
   defineXLCompatMacros(Builder);

clang/test/CodeGen/builtins-ppc-xlcompat-complex.c

+// RUN: %clang_cc1 -O2 -triple powerpc64-unknown-unknown \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s
+// RUN: %clang_cc1 -O2 -triple powerpc64le-unknown-unknown \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr8 | FileCheck %s
+// RUN: %clang_cc1 -O2 -triple powerpc-unknown-aix \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | \
+// RUN:   FileCheck %s --check-prefix=CHECK-AIX
+// RUN: %clang_cc1 -O2 -triple powerpc64-unknown-aix \
+// RUN:   -emit-llvm %s -o - -target-cpu pwr7 | FileCheck %s \
+// RUN:   --check-prefix=CHECK-AIX
+
+extern long double lda, ldb;
+
+long double _Complex test_cmplxl() {
+  // CHECK-LABEL: test_cmplxl
+  // CHECK: %0 = load ppc_fp128, ppc_fp128* @lda
+  // CHECK-NEXT: %1 = load ppc_fp128, ppc_fp128* @ldb
+  // CHECK-NEXT: %.fca.0.insert = insertvalue { ppc_fp128, ppc_fp128 } undef, ppc_fp128 %0, 0
+  // CHECK-NEXT: %.fca.1.insert = insertvalue { ppc_fp128, ppc_fp128 } %.fca.0.insert, ppc_fp128 %1, 1
+  // CHECK-NEXT: ret { ppc_fp128, ppc_fp128 } %.fca.1.insert
+
+  // CHECK-AIX-LABEL: test_cmplxl
+  // CHECK-AIX: %0 = load double, double* @lda
+  // CHECK-AIX-NEXT: %1 = load double, double* @ldb
+  // CHECK-AIX-NEXT: %.fca.0.insert = insertvalue { double, double } undef, double %0, 0
+  // CHECK-AIX-NEXT: %.fca.1.insert = insertvalue { double, double } %.fca.0.insert, double %1, 1
+  // CHECK-AIX-NEXT: ret { double, double } %.fca.1.insert
+  return __builtin_ppc_cmplxl(lda, ldb);
+}
+
+long double _Complex test_xl_cmplxl() {
+  // CHECK-LABEL: test_xl_cmplxl
+  // CHECK: %0 = load ppc_fp128, ppc_fp128* @lda
+  // CHECK-NEXT: %1 = load ppc_fp128, ppc_fp128* @ldb
+  // CHECK-NEXT: %.fca.0.insert = insertvalue { ppc_fp128, ppc_fp128 } undef, ppc_fp128 %0, 0
+  // CHECK-NEXT: %.fca.1.insert = insertvalue { ppc_fp128, ppc_fp128 } %.fca.0.insert, ppc_fp128 %1, 1
+  // CHECK-NEXT: ret { ppc_fp128, ppc_fp128 } %.fca.1.insert
+
+  // CHECK-AIX-LABEL: test_xl_cmplxl
+  // CHECK-AIX: %0 = load double, double* @lda
+  // CHECK-AIX-NEXT: %1 = load double, double* @ldb
+  // CHECK-AIX-NEXT: %.fca.0.insert = insertvalue { double, double } undef, double %0, 0
+  // CHECK-AIX-NEXT: %.fca.1.insert = insertvalue { double, double } %.fca.0.insert, double %1, 1
+  // CHECK-AIX-NEXT: ret { double, double } %.fca.1.insert
+  return __cmplxl(lda, ldb);
+}

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-complex-32bit-only.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -verify-machineinstrs -mtriple=powerpc-unknown-aix \
+; RUN:   -mcpu=pwr8 < %s | FileCheck %s
+
+@lda = external local_unnamed_addr global double, align 16
+@ldb = external local_unnamed_addr global double, align 16
+
+define { double, double } @test_long_double_complex() {
+; CHECK-LABEL: test_long_double_complex:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    lwz 3, L..C0(2) # @lda
+; CHECK-NEXT:    lwz 4, L..C1(2) # @ldb
+; CHECK-NEXT:    lfd 1, 0(3)
+; CHECK-NEXT:    lfd 2, 0(4)
+; CHECK-NEXT:    blr
+entry:
+  %0 = load double, double* @lda, align 16
+  %1 = load double, double* @ldb, align 16
+  %.fca.0.insert = insertvalue { double, double } undef, double %0, 0
+  %.fca.1.insert = insertvalue { double, double } %.fca.0.insert, double %1, 1
+  ret { double, double } %.fca.1.insert
+}

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-complex.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64le-unknown-linux-gnu \
+; RUN:   -mcpu=pwr8 < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-linux-gnu \
+; RUN:   -mcpu=pwr8 < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -mtriple=powerpc64-unknown-aix \
+; RUN:   -mcpu=pwr8 < %s | FileCheck %s --check-prefix=CHECK-AIX64
+
+@lda = external local_unnamed_addr global ppc_fp128, align 16
+@ldb = external local_unnamed_addr global ppc_fp128, align 16
+
+define { ppc_fp128, ppc_fp128 } @test_long_double_complex() {
+; CHECK-LABEL: test_long_double_complex:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    addis 3, 2, .LC0@toc@ha
+; CHECK-NEXT:    addis 4, 2, .LC1@toc@ha
+; CHECK-NEXT:    ld 3, .LC0@toc@l(3)
+; CHECK-NEXT:    ld 4, .LC1@toc@l(4)
+; CHECK-NEXT:    lfd 1, 0(3)
+; CHECK-NEXT:    lfd 2, 8(3)
+; CHECK-NEXT:    lfd 3, 0(4)
+; CHECK-NEXT:    lfd 4, 8(4)
+; CHECK-NEXT:    blr
+;
+; CHECK-AIX64-LABEL: test_long_double_complex:
+; CHECK-AIX64:       # %bb.0: # %entry
+; CHECK-AIX64-NEXT:    ld 3, L..C0(2) # @lda
+; CHECK-AIX64-NEXT:    ld 4, L..C1(2) # @ldb
+; CHECK-AIX64-NEXT:    lfd 1, 0(3)
+; CHECK-AIX64-NEXT:    lfd 2, 8(3)
+; CHECK-AIX64-NEXT:    lfd 3, 0(4)
+; CHECK-AIX64-NEXT:    lfd 4, 8(4)
+; CHECK-AIX64-NEXT:    blr
+entry:
+  %0 = load ppc_fp128, ppc_fp128* @lda, align 16
+  %1 = load ppc_fp128, ppc_fp128* @ldb, align 16
+  %.fca.0.insert = insertvalue { ppc_fp128, ppc_fp128 } undef, ppc_fp128 %0, 0
+  %.fca.1.insert = insertvalue { ppc_fp128, ppc_fp128 } %.fca.0.insert, ppc_fp128 %1, 1
+  ret { ppc_fp128, ppc_fp128 } %.fca.1.insert
+}
+