Skip to content

Commit

Permalink
Cleanup and progress
Browse files Browse the repository at this point in the history
  • Loading branch information
@wsmoses
wsmoses committed Sep 20, 2023
1 parent 870ccf6 commit d8b8972
Show file tree
Hide file tree
Showing 11 changed files with 304 additions and 263 deletions.
46 changes: 22 additions & 24 deletions enzyme/Enzyme/BlasDerivatives.td
View file
Original file line number Diff line number Diff line change
Expand Up @@ -109,8 +109,8 @@ def scal : CallBlasPattern<(Op $n, $alpha, $x, $incx),
["x"],[len, fp, vinc<["n"]>],
[
// dot must proceed scal, because scal modifies adj<"x">
(b<"dot"> $n, $x, $incx, adj<"x">, $incx),
(b<"scal"> $n, $alpha, adj<"x">, $incx)
(b<"dot"> $n, $x, adj<"x">),
(b<"scal"> $n, $alpha, adj<"x">)
]
>;

Expand Down Expand Up @@ -144,8 +144,8 @@ def axpy : CallBlasPattern<(Op $n, $alpha, $x, $incx, $y, $incy),
def dot : CallBlasPattern<(Op $n, $x, $incx, $y, $incy),
[],[len, vinc<["n"]>, vinc<["n"]>],
[
(b<"axpy"> $n, DiffeRet, $y, $incy, adj<"x">, $incx),
(b<"axpy"> $n, DiffeRet, $x, $incx, adj<"y">, $incy)
(b<"axpy"> $n, DiffeRet, $y, adj<"x">),
(b<"axpy"> $n, DiffeRet, $x, adj<"y">),
]
>;

Expand Down Expand Up @@ -185,22 +185,20 @@ def gemv : CallBlasPattern<(Op $layout, $transa, $m, $n, $alpha, $A, $lda, $x, $
["y"], [cblas_layout, trans, len, len, fp, mld<["m", "n"]>, vinc<["transa", "n", "m"]>, fp, vinc<["transa", "m", "n"]>],
[
/* alpha */ (Seq<["Ax", "is_normal", "transa", "m", "n"]>
(b<"gemv"> $layout, $transa, $m, $n, Constant<"1.0">, $A, (ld $A, $transa, $lda, $m, $n), $x, $incx, Constant<"0.0">, use<"Ax">, ConstantInt<1>),
(b<"dot"> (Rows $transa, $m, $n), adj<"y">, $incy, use<"Ax">, ConstantInt<1>)),
(b<"gemv"> $layout, $transa, $m, $n, Constant<"1.0">, $A, (ld $A, $transa, $lda, $m, $n), $x, Constant<"0.0">, use<"Ax">, ConstantInt<1>),
(b<"dot"> (Rows $transa, $m, $n), adj<"y">, use<"Ax">, ConstantInt<1>)),

//if (is_normal $transa) {
// call sger(m, n, alpha, ya, incy, x, incx, Aa, lda)
//} else {
// call sger(m, n, alpha, x, incx, ya, incy, Aa, lda)
//}
/* A */ (b<"ger"> $layout, $m, $n, $alpha, (Rows $transa, adj<"y">, $x),
(Rows $transa, $incy, $incx),
(Rows $transa, $x, adj<"y">),
(Rows $transa, $incx, $incy),
adj<"A">, $lda),
/* x */ (b<"gemv"> $layout, transpose<"transa">, $m, $n, $alpha, $A, (ld $A, $transa, $lda, $m, $n), adj<"y">, $incy, Constant<"1.0">, adj<"x">, $incx),
/* beta */ (b<"dot"> (Rows $transa, $m, $n), adj<"y">, $incy, input<"y">, $incy),
/* y */ (b<"scal"> (Rows $transa, $m, $n), $beta, adj<"y">, $incy)
adj<"A">),
/* x */ (b<"gemv"> $layout, transpose<"transa">, $m, $n, $alpha, $A, (ld $A, $transa, $lda, $m, $n), adj<"y">, Constant<"1.0">, adj<"x">),
/* beta */ (b<"dot"> (Rows $transa, $m, $n), adj<"y">, input<"y">),
/* y */ (b<"scal"> (Rows $transa, $m, $n), $beta, adj<"y">)
]
>;
//
Expand All @@ -227,11 +225,11 @@ def gemm : CallBlasPattern<(Op $layout, $transa, $transb, $m, $n, $k, $alpha, $A

/* alpha */ (Seq<["AB", "product", "m", "n"]>
(b<"gemm"> $layout, $transa, $transb, $m, $n, $k, Constant<"1.0">, $A, (ld $A, $transa, $lda, $m, $k), $B, (ld $B, $transb, $ldb, $k, $n), Constant<"0.0">, use<"AB">, $m),// TODO: check if last arg should be $m or $n
(FrobInnerProd<""> $m, $n, adj<"C">, $ldc, use<"AB">)),
/* A */ (b<"gemm"> $layout, $transa, transpose<"transb">, $m, $k, $n, $alpha, adj<"C">, $ldc, $B, (ld $B, $transb, $ldb, $k, $n), $beta, adj<"A">, $lda),
/* B */ (b<"gemm"> $layout, transpose<"transa">, $transb, $k, $n, $m, $alpha, $A, (ld $A, $transa, $lda, $m, $k), adj<"C">, $ldc, $beta, adj<"B">, $ldb),
/* beta */ (FrobInnerProd<""> $m, $n, adj<"C">, $ldc, input<"C">),
/* C */ (b<"lascl"> $layout, Char<"G">, ConstantInt<0>, ConstantInt<0>, Constant<"1.0">, $beta, $m, $n, adj<"C">, $ldc, ConstantInt<0>)
(FrobInnerProd<""> $m, $n, adj<"C">, use<"AB">)),
/* A */ (b<"gemm"> $layout, $transa, transpose<"transb">, $m, $k, $n, $alpha, adj<"C">, $B, (ld $B, $transb, $ldb, $k, $n), $beta, adj<"A">),
/* B */ (b<"gemm"> $layout, transpose<"transa">, $transb, $k, $n, $m, $alpha, $A, (ld $A, $transa, $lda, $m, $k), adj<"C">, $beta, adj<"B">),
/* beta */ (FrobInnerProd<""> $m, $n, adj<"C">, input<"C">),
/* C */ (b<"lascl"> $layout, Char<"G">, ConstantInt<0>, ConstantInt<0>, Constant<"1.0">, $beta, $m, $n, adj<"C">, ConstantInt<0>)
]
>;

Expand All @@ -240,14 +238,14 @@ def spmv : CallBlasPattern<(Op $layout, $uplo, $n, $alpha, $ap, $x, $incx, $beta
[cblas_layout, uplo, len, fp, ap<["n"]>, vinc<["n"]>, fp, vinc<["n"]>],
[
/* alpha */ (Seq<["y0", "triangular", "n"]>
(b<"spmv"> $layout, $uplo, $n, Constant<"1.0">, $ap, $x, $incx, Constant<"0.0">, use<"y0">, ConstantInt<1>),
(b<"dot"> $n, adj<"y">, $incy, use<"y0">, ConstantInt<1>)),
(b<"spmv"> $layout, $uplo, $n, Constant<"1.0">, $ap, $x, Constant<"0.0">, use<"y0">, ConstantInt<1>),
(b<"dot"> $n, adj<"y">, use<"y0">, ConstantInt<1>)),
/* ap */ (Seq<[]>
(b<"spr2"> $layout, $uplo, $n, $alpha, $x, $incx, adj<"y">, $incy, adj<"ap">),
(DiagUpdateSPMV<""> $uplo, $n, $alpha, $x, $incx, adj<"y">, $incy, adj<"ap">)),
/* x */ (b<"spmv"> $layout, $uplo, $n, $alpha, $ap, adj<"y">, $incy, Constant<"1.0">, adj<"x">, $incx),
/* beta */ (b<"dot"> $n, adj<"y">, $incy, input<"y">, $incy),
/* y */ (b<"scal"> $n, $beta, adj<"y">, $incy)
(b<"spr2"> $layout, $uplo, $n, $alpha, $x, adj<"y">, adj<"ap">),
(DiagUpdateSPMV<""> $uplo, $n, $alpha, $x, adj<"y">, adj<"ap">)),
/* x */ (b<"spmv"> $layout, $uplo, $n, $alpha, $ap, adj<"y">, Constant<"1.0">, adj<"x">),
/* beta */ (b<"dot"> $n, adj<"y">, input<"y">),
/* y */ (b<"scal"> $n, $beta, adj<"y">)
]
>;

Expand Down
18 changes: 12 additions & 6 deletions enzyme/Enzyme/Utils.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2593,19 +2593,25 @@ llvm::Value *load_if_ref(llvm::IRBuilder<> &B, llvm::IntegerType *intType,
return B.CreateLoad(intType, VP);
}

llvm::Value *get_blas_row(llvm::IRBuilder<> &B, llvm::Value *trans,
llvm::Value *row, llvm::Value *col, bool byRef) {

SmallVector<llvm::Value *, 1> get_blas_row(llvm::IRBuilder<> &B, ArrayRef<llvm::Value *>transA,
ArrayRef<llvm::Value *> row, ArrayRef<llvm::Value *> col, bool byRef) {
assert(transA.size() == 1);
auto trans = transA[0];
if (byRef) {
auto charType = IntegerType::get(trans->getContext(), 8);
trans = B.CreateLoad(charType, trans, "ld.row.trans");
}

return B.CreateSelect(
auto cond =
B.CreateOr(
B.CreateICmpEQ(trans, ConstantInt::get(trans->getType(), 'N')),
B.CreateICmpEQ(trans, ConstantInt::get(trans->getType(), 'n'))),
row, col);
B.CreateICmpEQ(trans, ConstantInt::get(trans->getType(), 'n')));
assert(row.size() == col.size());
SmallVector<Value*, 1> toreturn;
for (size_t i=0; i<row.size(); i++) {
toreturn.push_back(B.CreateSelect(cond, row[i], col[i]));
}
return toreturn;
}

// return how many Special pointers are in T (count > 0),
Expand Down
4 changes: 2 additions & 2 deletions enzyme/Enzyme/Utils.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1651,8 +1651,8 @@ llvm::Value *transpose(llvm::IRBuilder<> &B, llvm::Value *V);
llvm::Value *transpose(llvm::IRBuilder<> &B, llvm::Value *V, bool byRef,
llvm::IntegerType *IT, llvm::IRBuilder<> &entryBuilder,
const llvm::Twine &name);
llvm::Value *get_blas_row(llvm::IRBuilder<> &B, llvm::Value *trans,
llvm::Value *row, llvm::Value *col, bool byRef);
llvm::SmallVector<llvm::Value *, 1> get_blas_row(llvm::IRBuilder<> &B, llvm::ArrayRef<llvm::Value *> trans,
llvm::ArrayRef<llvm::Value *> row, llvm::ArrayRef<llvm::Value *> col, bool byRef);

// Parameter attributes from the original function/call that
// we should preserve on the primal of the derivative code.
Expand Down
2 changes: 1 addition & 1 deletion enzyme/test/Enzyme/ReverseMode/blas/gemv_c_loop.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,7 +55,7 @@ entry:
; CHECK-NEXT: %mallocsize = mul nuw nsw i32 %0, 8
; CHECK-NEXT: %malloccall = tail call noalias nonnull i8* @malloc(i32 %mallocsize)
; CHECK-NEXT: %cache.A = bitcast i8* %malloccall to double*
; CHECK-NEXT: call void @dlacpy(i8 0, i32 %N, i32 %N, double* %K, i32 %N, double* %cache.A, i32 %N)
; CHECK-NEXT: call void @cblas_dlacpy(i32 101, i8 0, i32 %N, i32 %N, double* %K, i32 %N, double* %cache.A, i32 %N)
; CHECK-NEXT: %1 = select i1 false, i32 %N, i32 %N
; CHECK-NEXT: %mallocsize1 = mul nuw nsw i32 %1, 8
; CHECK-NEXT: %malloccall2 = tail call noalias nonnull i8* @malloc(i32 %mallocsize1)
Expand Down
2 changes: 1 addition & 1 deletion enzyme/test/Enzyme/ReverseMode/blas/gemv_c_loop2.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,7 +55,7 @@ entry:
; CHECK-NEXT: %mallocsize = mul nuw nsw i32 %0, 8
; CHECK-NEXT: %malloccall = tail call noalias nonnull i8* @malloc(i32 %mallocsize)
; CHECK-NEXT: %cache.A = bitcast i8* %malloccall to double*
; CHECK-NEXT: call void @dlacpy(i8 0, i32 %N, i32 %N, double* %K, i32 %N, double* %cache.A, i32 %N)
; CHECK-NEXT: call void @cblas_dlacpy(i32 101, i8 0, i32 %N, i32 %N, double* %K, i32 %N, double* %cache.A, i32 %N)
; CHECK-NEXT: %1 = select i1 false, i32 %N, i32 %N
; CHECK-NEXT: %mallocsize1 = mul nuw nsw i32 %1, 8
; CHECK-NEXT: %malloccall2 = tail call noalias nonnull i8* @malloc(i32 %mallocsize1)
Expand Down
36 changes: 14 additions & 22 deletions enzyme/test/Enzyme/ReverseMode/blas/gemv_f_c_split_blascpy.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -118,7 +118,7 @@ entry:
; CHECK-NEXT: %byref.constant.fp.0.0 = alloca double
; CHECK-NEXT: %byref.constant.int.1 = alloca i64
; CHECK-NEXT: %byref.constant.int.17 = alloca i64
; CHECK-NEXT: %byref.constant.fp.1.013 = alloca double
; CHECK-NEXT: %[[byrefconstantfp1:.+]] = alloca double
; CHECK-NEXT: %incy = alloca i64, i64 1, align 16
; CHECK-NEXT: %1 = bitcast i64* %incy to i8*
; CHECK-NEXT: %incx = alloca i64, i64 1, align 16
Expand Down Expand Up @@ -204,38 +204,30 @@ entry:
; CHECK-DAG: %[[i40:.+]] = icmp eq i8 %ld.row.trans9, 78
; CHECK-NEXT: %[[i41:.+]] = or i1 %[[i40]], %[[i39]]
; CHECK-NEXT: %[[i42:.+]] = select i1 %41, i8* %"y'", i8* %20
; CHECK-NEXT: %[[i46:.+]] = select i1 %[[i41]], i8* %incy_p, i8* %intcast.int.one
; CHECK-NEXT: %ld.row.trans10 = load i8, i8* %malloccall, align 1
; CHECK-DAG: %[[i43:.+]] = icmp eq i8 %ld.row.trans10, 110
; CHECK-DAG: %[[i44:.+]] = icmp eq i8 %ld.row.trans10, 78
; CHECK-NEXT: %[[i45:.+]] = or i1 %[[i44]], %[[i43]]
; CHECK-NEXT: %[[i46:.+]] = select i1 %[[i45]], i8* %incy_p, i8* %incx_p
; CHECK-NEXT: %ld.row.trans11 = load i8, i8* %malloccall, align 1
; CHECK-DAG: %[[i47:.+]] = icmp eq i8 %ld.row.trans11, 110
; CHECK-DAG: %[[i48:.+]] = icmp eq i8 %ld.row.trans11, 78
; CHECK-DAG: %[[i47:.+]] = icmp eq i8 %ld.row.trans10, 110
; CHECK-DAG: %[[i48:.+]] = icmp eq i8 %ld.row.trans10, 78
; CHECK-NEXT: %[[i49:.+]] = or i1 %[[i48]], %[[i47]]
; CHECK-NEXT: %[[i50:.+]] = select i1 %[[i49]], i8* %20, i8* %"y'"
; CHECK-NEXT: %ld.row.trans12 = load i8, i8* %malloccall, align 1
; CHECK-NEXT: %[[i51:.+]] = icmp eq i8 %ld.row.trans12, 110
; CHECK-NEXT: %[[i52:.+]] = icmp eq i8 %ld.row.trans12, 78
; CHECK-NEXT: %[[i53:.+]] = or i1 %52, %51
; CHECK-NEXT: %[[i54:.+]] = select i1 %53, i8* %incx_p, i8* %incy_p
; CHECK-NEXT: %[[i54:.+]] = select i1 %[[i49]], i8* %intcast.int.one, i8* %incy_p
; CHECK-NEXT: call void @dger_64_(i8* %m_p, i8* %n_p, i8* %alpha, i8* %[[i42]], i8* %[[i46]], i8* %[[i50]], i8* %[[i54]], i8* %"A'", i8* %lda_p)
; CHECK-NEXT: store double 1.000000e+00, double* %byref.constant.fp.1.013
; CHECK-NEXT: %fpcast.constant.fp.1.014 = bitcast double* %byref.constant.fp.1.013 to i8*
; CHECK-NEXT: call void @dgemv_64_(i8* %byref.transpose.transa, i8* %m_p, i8* %n_p, i8* %alpha, i8* %A, i8* %lda_p, i8* %"y'", i8* %incy_p, i8* %fpcast.constant.fp.1.014, i8* %"x'", i8* %incx_p)
; CHECK-NEXT: %ld.row.trans15 = load i8, i8* %malloccall
; CHECK-DAG: %[[r39:.+]] = icmp eq i8 %ld.row.trans15, 110
; CHECK-DAG: %[[r40:.+]] = icmp eq i8 %ld.row.trans15, 78
; CHECK-NEXT: store double 1.000000e+00, double* %[[byrefconstantfp1]]
; CHECK-NEXT: %[[fpcast14:.+]] = bitcast double* %[[byrefconstantfp1]] to i8*
; CHECK-NEXT: call void @dgemv_64_(i8* %byref.transpose.transa, i8* %m_p, i8* %n_p, i8* %alpha, i8* %A, i8* %lda_p, i8* %"y'", i8* %incy_p, i8* %[[fpcast14]], i8* %"x'", i8* %incx_p)
; CHECK-NEXT: %ld.row.trans13 = load i8, i8* %malloccall
; CHECK-DAG: %[[r39:.+]] = icmp eq i8 %ld.row.trans13, 110
; CHECK-DAG: %[[r40:.+]] = icmp eq i8 %ld.row.trans13, 78
; CHECK-NEXT: %[[r41:.+]] = or i1 %[[r40]], %[[r39]]
; CHECK-NEXT: %[[r42:.+]] = select i1 %[[r41]], i8* %m_p, i8* %n_p
; CHECK-NEXT: %[[r43:.+]] = call fast double @ddot_64_(i8* %[[r42]], i8* %"y'", i8* %incy_p, i8* %21, i8* %intcast.int.one)
; CHECK-NEXT: %[[r44:.+]] = bitcast i8* %"beta'" to double*
; CHECK-NEXT: %[[r45:.+]] = load double, double* %[[r44]]
; CHECK-NEXT: %[[r46:.+]] = fadd fast double %[[r45]], %[[r43]]
; CHECK-NEXT: store double %[[r46]], double* %[[r44]]
; CHECK-NEXT: %ld.row.trans16 = load i8, i8* %malloccall
; CHECK-DAG: %[[r47:.+]] = icmp eq i8 %ld.row.trans16, 110
; CHECK-DAG: %[[r48:.+]] = icmp eq i8 %ld.row.trans16, 78
; CHECK-NEXT: %ld.row.trans14 = load i8, i8* %malloccall
; CHECK-DAG: %[[r47:.+]] = icmp eq i8 %ld.row.trans14, 110
; CHECK-DAG: %[[r48:.+]] = icmp eq i8 %ld.row.trans14, 78
; CHECK-NEXT: %[[r49:.+]] = or i1 %[[r48]], %[[r47]]
; CHECK-NEXT: %[[r50:.+]] = select i1 %[[r49]], i8* %m_p, i8* %n_p
; CHECK-NEXT: call void @dscal_64_(i8* %[[r50]], i8* %beta, i8* %"y'", i8* %incy_p)
Expand Down
28 changes: 10 additions & 18 deletions enzyme/test/Enzyme/ReverseMode/blas/gemv_f_c_split_blascpy_runtime_act.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -176,31 +176,23 @@ entry:
; CHECK-DAG: %[[r23:.+]] = icmp eq i8 %ld.row.trans, 78
; CHECK-NEXT: %[[r24:.+]] = or i1 %[[r23]], %[[r22]]
; CHECK-NEXT: %[[r25:.+]] = select i1 %[[r24]], i8* %"y'", i8* %11
; CHECK-NEXT: %[[r29:.+]] = select i1 %[[r24]], i8* %incy_p, i8* %intcast.int.one
; CHECK-NEXT: %ld.row.trans2 = load i8, i8* %malloccall, align 1
; CHECK-DAG: %[[r26:.+]] = icmp eq i8 %ld.row.trans2, 110
; CHECK-DAG: %[[r27:.+]] = icmp eq i8 %ld.row.trans2, 78
; CHECK-NEXT: %[[r28:.+]] = or i1 %[[r27]], %[[r26]]
; CHECK-NEXT: %[[r29:.+]] = select i1 %[[r28]], i8* %incy_p, i8* %incx_p
; CHECK-NEXT: %ld.row.trans3 = load i8, i8* %malloccall, align 1
; CHECK-DAG: %[[r30:.+]] = icmp eq i8 %ld.row.trans3, 110
; CHECK-DAG: %[[r31:.+]] = icmp eq i8 %ld.row.trans3, 78
; CHECK-DAG: %[[r30:.+]] = icmp eq i8 %ld.row.trans2, 110
; CHECK-DAG: %[[r31:.+]] = icmp eq i8 %ld.row.trans2, 78
; CHECK-NEXT: %[[r32:.+]] = or i1 %[[r31]], %[[r30]]
; CHECK-NEXT: %[[r33:.+]] = select i1 %[[r32]], i8* %11, i8* %"y'"
; CHECK-NEXT: %ld.row.trans4 = load i8, i8* %malloccall, align 1
; CHECK-DAG: %[[r34:.+]] = icmp eq i8 %ld.row.trans4, 110
; CHECK-DAG: %[[r35:.+]] = icmp eq i8 %ld.row.trans4, 78
; CHECK-NEXT: %[[r36:.+]] = or i1 %[[r35]], %[[r34]]
; CHECK-NEXT: %[[r37:.+]] = select i1 %[[r36]], i8* %incx_p, i8* %incy_p
; CHECK-NEXT: %[[r37:.+]] = select i1 %[[r32]], i8* %intcast.int.one, i8* %incy_p
; CHECK-NEXT: call void @dger_64_(i8* %m_p, i8* %n_p, i8* %alpha, i8* %[[r25]], i8* %[[r29]], i8* %[[r33]], i8* %[[r37]], i8* %"A'", i8* %lda_p)
; CHECK-NEXT: br label %invertentry.A.done

; CHECK: invertentry.A.done: ; preds = %invertentry.A.active, %invertentry
; CHECK-NEXT: br i1 %rt.inactive.beta, label %invertentry.beta.done, label %invertentry.beta.active

; CHECK: invertentry.beta.active: ; preds = %invertentry.A.done
; CHECK-NEXT: %ld.row.trans5 = load i8, i8* %malloccall
; CHECK-DAG: %[[r39:.+]] = icmp eq i8 %ld.row.trans5, 110
; CHECK-DAG: %[[r40:.+]] = icmp eq i8 %ld.row.trans5, 78
; CHECK-NEXT: %ld.row.trans3 = load i8, i8* %malloccall
; CHECK-DAG: %[[r39:.+]] = icmp eq i8 %ld.row.trans3, 110
; CHECK-DAG: %[[r40:.+]] = icmp eq i8 %ld.row.trans3, 78
; CHECK-NEXT: %[[r41:.+]] = or i1 %[[r40]], %[[r39]]
; CHECK-NEXT: %[[r42:.+]] = select i1 %[[r41]], i8* %m_p, i8* %n_p
; CHECK-NEXT: %[[r43:.+]] = call fast double @ddot_64_(i8* %[[r42]], i8* %"y'", i8* %incy_p, i8* %[[i12]], i8* %intcast.int.one)
Expand All @@ -214,9 +206,9 @@ entry:
; CHECK-NEXT: br i1 %rt.inactive.y, label %invertentry.y.done, label %invertentry.y.active

; CHECK: invertentry.y.active: ; preds = %invertentry.beta.done
; CHECK-NEXT: %ld.row.trans6 = load i8, i8* %malloccall
; CHECK-DAG: %[[r47:.+]] = icmp eq i8 %ld.row.trans6, 110
; CHECK-DAG: %[[r48:.+]] = icmp eq i8 %ld.row.trans6, 78
; CHECK-NEXT: %ld.row.trans4 = load i8, i8* %malloccall
; CHECK-DAG: %[[r47:.+]] = icmp eq i8 %ld.row.trans4, 110
; CHECK-DAG: %[[r48:.+]] = icmp eq i8 %ld.row.trans4, 78
; CHECK-NEXT: %[[r49:.+]] = or i1 %[[r48]], %[[r47]]
; CHECK-NEXT: %[[r50:.+]] = select i1 %[[r49]], i8* %m_p, i8* %n_p
; CHECK-NEXT: call void @dscal_64_(i8* %[[r50]], i8* %beta, i8* %"y'", i8* %incy_p)
Expand Down
Loading

0 comments on commit d8b8972

Please sign in to comment.