Skip to content

Commit

Permalink
[PowerPC] Implement cmplxl builtins
Browse files Browse the repository at this point in the history 
This patch implements the builtins for cmplxl by utilising
__builtin_complex. This builtin is implemented to match XL
functionality.

Differential revision: https://reviews.llvm.org/D107138
  • Loading branch information
@Conanap
Conanap committed Aug 20, 2021
1 parent 3205ee7 commit 9d4faa8
Show file tree
Hide file tree
Showing 2 changed files with 113 additions and 0 deletions.
1 change: 1 addition & 0 deletions clang/lib/Basic/Targets/PPC.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -237,6 +237,7 @@ static void defineXLCompatMacros(MacroBuilder &Builder) {
Builder.defineMacro("__fsqrt", "__builtin_ppc_fsqrt");
Builder.defineMacro("__fsqrts", "__builtin_ppc_fsqrts");
Builder.defineMacro("__addex", "__builtin_ppc_addex");
Builder.defineMacro("__cmplxl", "__builtin_complex");
}

/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
Expand Down
112 changes: 112 additions & 0 deletions clang/test/CodeGen/builtins-ppc-xlcompat-cmplx.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -226,3 +226,115 @@ double _Complex testcmplx(double real, double imag) {
float _Complex testcmplxf(float real, float imag) {
return __cmplxf(real, imag);
}

// 64BIT-LABEL: @test_xl_cmplxl(
// 64BIT-NEXT: entry:
// 64BIT-NEXT: [[RETVAL:%.*]] = alloca { ppc_fp128, ppc_fp128 }, align 16
// 64BIT-NEXT: [[LDA_ADDR:%.*]] = alloca ppc_fp128, align 16
// 64BIT-NEXT: [[LDB_ADDR:%.*]] = alloca ppc_fp128, align 16
// 64BIT-NEXT: store ppc_fp128 [[LDA:%.*]], ppc_fp128* [[LDA_ADDR]], align 16
// 64BIT-NEXT: store ppc_fp128 [[LDB:%.*]], ppc_fp128* [[LDB_ADDR]], align 16
// 64BIT-NEXT: [[TMP0:%.*]] = load ppc_fp128, ppc_fp128* [[LDA_ADDR]], align 16
// 64BIT-NEXT: [[TMP1:%.*]] = load ppc_fp128, ppc_fp128* [[LDB_ADDR]], align 16
// 64BIT-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[RETVAL]], i32 0, i32 0
// 64BIT-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[RETVAL]], i32 0, i32 1
// 64BIT-NEXT: store ppc_fp128 [[TMP0]], ppc_fp128* [[RETVAL_REALP]], align 16
// 64BIT-NEXT: store ppc_fp128 [[TMP1]], ppc_fp128* [[RETVAL_IMAGP]], align 16
// 64BIT-NEXT: [[TMP2:%.*]] = load { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[RETVAL]], align 16
// 64BIT-NEXT: ret { ppc_fp128, ppc_fp128 } [[TMP2]]
//
// 64BITLE-LABEL: @test_xl_cmplxl(
// 64BITLE-NEXT: entry:
// 64BITLE-NEXT: [[RETVAL:%.*]] = alloca { ppc_fp128, ppc_fp128 }, align 16
// 64BITLE-NEXT: [[LDA_ADDR:%.*]] = alloca ppc_fp128, align 16
// 64BITLE-NEXT: [[LDB_ADDR:%.*]] = alloca ppc_fp128, align 16
// 64BITLE-NEXT: store ppc_fp128 [[LDA:%.*]], ppc_fp128* [[LDA_ADDR]], align 16
// 64BITLE-NEXT: store ppc_fp128 [[LDB:%.*]], ppc_fp128* [[LDB_ADDR]], align 16
// 64BITLE-NEXT: [[TMP0:%.*]] = load ppc_fp128, ppc_fp128* [[LDA_ADDR]], align 16
// 64BITLE-NEXT: [[TMP1:%.*]] = load ppc_fp128, ppc_fp128* [[LDB_ADDR]], align 16
// 64BITLE-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[RETVAL]], i32 0, i32 0
// 64BITLE-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[RETVAL]], i32 0, i32 1
// 64BITLE-NEXT: store ppc_fp128 [[TMP0]], ppc_fp128* [[RETVAL_REALP]], align 16
// 64BITLE-NEXT: store ppc_fp128 [[TMP1]], ppc_fp128* [[RETVAL_IMAGP]], align 16
// 64BITLE-NEXT: [[TMP2:%.*]] = load { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[RETVAL]], align 16
// 64BITLE-NEXT: ret { ppc_fp128, ppc_fp128 } [[TMP2]]
//
// 64BITAIX-LABEL: @test_xl_cmplxl(
// 64BITAIX-NEXT: entry:
// 64BITAIX-NEXT: [[RETVAL:%.*]] = alloca { double, double }, align 4
// 64BITAIX-NEXT: [[LDA_ADDR:%.*]] = alloca double, align 8
// 64BITAIX-NEXT: [[LDB_ADDR:%.*]] = alloca double, align 8
// 64BITAIX-NEXT: store double [[LDA:%.*]], double* [[LDA_ADDR]], align 8
// 64BITAIX-NEXT: store double [[LDB:%.*]], double* [[LDB_ADDR]], align 8
// 64BITAIX-NEXT: [[TMP0:%.*]] = load double, double* [[LDA_ADDR]], align 8
// 64BITAIX-NEXT: [[TMP1:%.*]] = load double, double* [[LDB_ADDR]], align 8
// 64BITAIX-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { double, double }, { double, double }* [[RETVAL]], i32 0, i32 0
// 64BITAIX-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { double, double }, { double, double }* [[RETVAL]], i32 0, i32 1
// 64BITAIX-NEXT: store double [[TMP0]], double* [[RETVAL_REALP]], align 4
// 64BITAIX-NEXT: store double [[TMP1]], double* [[RETVAL_IMAGP]], align 4
// 64BITAIX-NEXT: [[TMP2:%.*]] = load { double, double }, { double, double }* [[RETVAL]], align 4
// 64BITAIX-NEXT: ret { double, double } [[TMP2]]
//
// 32BIT-LABEL: @test_xl_cmplxl(
// 32BIT-NEXT: entry:
// 32BIT-NEXT: [[LDA_ADDR:%.*]] = alloca ppc_fp128, align 16
// 32BIT-NEXT: [[LDB_ADDR:%.*]] = alloca ppc_fp128, align 16
// 32BIT-NEXT: store ppc_fp128 [[LDA:%.*]], ppc_fp128* [[LDA_ADDR]], align 16
// 32BIT-NEXT: store ppc_fp128 [[LDB:%.*]], ppc_fp128* [[LDB_ADDR]], align 16
// 32BIT-NEXT: [[TMP0:%.*]] = load ppc_fp128, ppc_fp128* [[LDA_ADDR]], align 16
// 32BIT-NEXT: [[TMP1:%.*]] = load ppc_fp128, ppc_fp128* [[LDB_ADDR]], align 16
// 32BIT-NEXT: [[AGG_RESULT_REALP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT:%.*]], i32 0, i32 0
// 32BIT-NEXT: [[AGG_RESULT_IMAGP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 1
// 32BIT-NEXT: store ppc_fp128 [[TMP0]], ppc_fp128* [[AGG_RESULT_REALP]], align 16
// 32BIT-NEXT: store ppc_fp128 [[TMP1]], ppc_fp128* [[AGG_RESULT_IMAGP]], align 16
// 32BIT-NEXT: [[AGG_RESULT_REALP1:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 0
// 32BIT-NEXT: [[AGG_RESULT_REAL:%.*]] = load ppc_fp128, ppc_fp128* [[AGG_RESULT_REALP1]], align 16
// 32BIT-NEXT: [[AGG_RESULT_IMAGP2:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 1
// 32BIT-NEXT: [[AGG_RESULT_IMAG:%.*]] = load ppc_fp128, ppc_fp128* [[AGG_RESULT_IMAGP2]], align 16
// 32BIT-NEXT: [[AGG_RESULT_REALP3:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 0
// 32BIT-NEXT: [[AGG_RESULT_IMAGP4:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 1
// 32BIT-NEXT: store ppc_fp128 [[AGG_RESULT_REAL]], ppc_fp128* [[AGG_RESULT_REALP3]], align 16
// 32BIT-NEXT: store ppc_fp128 [[AGG_RESULT_IMAG]], ppc_fp128* [[AGG_RESULT_IMAGP4]], align 16
// 32BIT-NEXT: ret void
//
// 32BITLE-LABEL: @test_xl_cmplxl(
// 32BITLE-NEXT: entry:
// 32BITLE-NEXT: [[LDA_ADDR:%.*]] = alloca ppc_fp128, align 16
// 32BITLE-NEXT: [[LDB_ADDR:%.*]] = alloca ppc_fp128, align 16
// 32BITLE-NEXT: store ppc_fp128 [[LDA:%.*]], ppc_fp128* [[LDA_ADDR]], align 16
// 32BITLE-NEXT: store ppc_fp128 [[LDB:%.*]], ppc_fp128* [[LDB_ADDR]], align 16
// 32BITLE-NEXT: [[TMP0:%.*]] = load ppc_fp128, ppc_fp128* [[LDA_ADDR]], align 16
// 32BITLE-NEXT: [[TMP1:%.*]] = load ppc_fp128, ppc_fp128* [[LDB_ADDR]], align 16
// 32BITLE-NEXT: [[AGG_RESULT_REALP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT:%.*]], i32 0, i32 0
// 32BITLE-NEXT: [[AGG_RESULT_IMAGP:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 1
// 32BITLE-NEXT: store ppc_fp128 [[TMP0]], ppc_fp128* [[AGG_RESULT_REALP]], align 16
// 32BITLE-NEXT: store ppc_fp128 [[TMP1]], ppc_fp128* [[AGG_RESULT_IMAGP]], align 16
// 32BITLE-NEXT: [[AGG_RESULT_REALP1:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 0
// 32BITLE-NEXT: [[AGG_RESULT_REAL:%.*]] = load ppc_fp128, ppc_fp128* [[AGG_RESULT_REALP1]], align 16
// 32BITLE-NEXT: [[AGG_RESULT_IMAGP2:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 1
// 32BITLE-NEXT: [[AGG_RESULT_IMAG:%.*]] = load ppc_fp128, ppc_fp128* [[AGG_RESULT_IMAGP2]], align 16
// 32BITLE-NEXT: [[AGG_RESULT_REALP3:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 0
// 32BITLE-NEXT: [[AGG_RESULT_IMAGP4:%.*]] = getelementptr inbounds { ppc_fp128, ppc_fp128 }, { ppc_fp128, ppc_fp128 }* [[AGG_RESULT]], i32 0, i32 1
// 32BITLE-NEXT: store ppc_fp128 [[AGG_RESULT_REAL]], ppc_fp128* [[AGG_RESULT_REALP3]], align 16
// 32BITLE-NEXT: store ppc_fp128 [[AGG_RESULT_IMAG]], ppc_fp128* [[AGG_RESULT_IMAGP4]], align 16
// 32BITLE-NEXT: ret void
//
// 32BITAIX-LABEL: @test_xl_cmplxl(
// 32BITAIX-NEXT: entry:
// 32BITAIX-NEXT: [[RETVAL:%.*]] = alloca { double, double }, align 4
// 32BITAIX-NEXT: [[LDA_ADDR:%.*]] = alloca double, align 8
// 32BITAIX-NEXT: [[LDB_ADDR:%.*]] = alloca double, align 8
// 32BITAIX-NEXT: store double [[LDA:%.*]], double* [[LDA_ADDR]], align 8
// 32BITAIX-NEXT: store double [[LDB:%.*]], double* [[LDB_ADDR]], align 8
// 32BITAIX-NEXT: [[TMP0:%.*]] = load double, double* [[LDA_ADDR]], align 8
// 32BITAIX-NEXT: [[TMP1:%.*]] = load double, double* [[LDB_ADDR]], align 8
// 32BITAIX-NEXT: [[RETVAL_REALP:%.*]] = getelementptr inbounds { double, double }, { double, double }* [[RETVAL]], i32 0, i32 0
// 32BITAIX-NEXT: [[RETVAL_IMAGP:%.*]] = getelementptr inbounds { double, double }, { double, double }* [[RETVAL]], i32 0, i32 1
// 32BITAIX-NEXT: store double [[TMP0]], double* [[RETVAL_REALP]], align 4
// 32BITAIX-NEXT: store double [[TMP1]], double* [[RETVAL_IMAGP]], align 4
// 32BITAIX-NEXT: [[TMP2:%.*]] = load { double, double }, { double, double }* [[RETVAL]], align 4
// 32BITAIX-NEXT: ret { double, double } [[TMP2]]
//
long double _Complex test_xl_cmplxl(long double lda, long double ldb) {
return __cmplxl(lda, ldb);
}

0 comments on commit 9d4faa8

Please sign in to comment.