maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[IR] Remove support for float binop constant expressions 

As part of https://discourse.llvm.org/t/rfc-remove-most-constant-expressions/63179,
this removes support for the floating-point binop constant expressions
fadd, fsub, fmul, fdiv and frem.

As part of this change, the C APIs LLVMConstFAdd, LLVMConstFSub,
LLVMConstFMul, LLVMConstFDiv and LLVMConstFRem are removed.
The LLVMBuild APIs should be used instead.

Differential Revision: https://reviews.llvm.org/D129478
This commit is contained in:
Nikita Popov 2022-07-08 16:54:49 +02:00
parent 3c4468e67f
commit 4bb7b6fae3
23 changed files with 83 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
llvm/bindings/go/llvm/ir.go
View File

@ -909,17 +909,12 @@ func ConstNot(v Value) (rv Value) { rv.C = C.LLVMConstNot(v.C); retu
func ConstAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAdd(lhs.C, rhs.C); return }
func ConstNSWAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNSWAdd(lhs.C, rhs.C); return }
func ConstNUWAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNUWAdd(lhs.C, rhs.C); return }
func ConstFAdd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFAdd(lhs.C, rhs.C); return }
func ConstSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstSub(lhs.C, rhs.C); return }
func ConstNSWSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNSWSub(lhs.C, rhs.C); return }
func ConstNUWSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNUWSub(lhs.C, rhs.C); return }
func ConstFSub(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFSub(lhs.C, rhs.C); return }
func ConstMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstMul(lhs.C, rhs.C); return }
func ConstNSWMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNSWMul(lhs.C, rhs.C); return }
func ConstNUWMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstNUWMul(lhs.C, rhs.C); return }
func ConstFMul(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFMul(lhs.C, rhs.C); return }
func ConstFDiv(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFDiv(lhs.C, rhs.C); return }
func ConstFRem(lhs, rhs Value) (v Value) { v.C = C.LLVMConstFRem(lhs.C, rhs.C); return }
func ConstAnd(lhs, rhs Value) (v Value) { v.C = C.LLVMConstAnd(lhs.C, rhs.C); return }
func ConstOr(lhs, rhs Value) (v Value) { v.C = C.LLVMConstOr(lhs.C, rhs.C); return }
func ConstXor(lhs, rhs Value) (v Value) { v.C = C.LLVMConstXor(lhs.C, rhs.C); return }

5
llvm/bindings/ocaml/llvm/llvm.ml
View File

@ -642,17 +642,12 @@ external const_not : llvalue -> llvalue = "LLVMConstNot"
external const_add : llvalue -> llvalue -> llvalue = "LLVMConstAdd"
external const_nsw_add : llvalue -> llvalue -> llvalue = "LLVMConstNSWAdd"
external const_nuw_add : llvalue -> llvalue -> llvalue = "LLVMConstNUWAdd"
external const_fadd : llvalue -> llvalue -> llvalue = "LLVMConstFAdd"
external const_sub : llvalue -> llvalue -> llvalue = "LLVMConstSub"
external const_nsw_sub : llvalue -> llvalue -> llvalue = "LLVMConstNSWSub"
external const_nuw_sub : llvalue -> llvalue -> llvalue = "LLVMConstNUWSub"
external const_fsub : llvalue -> llvalue -> llvalue = "LLVMConstFSub"
external const_mul : llvalue -> llvalue -> llvalue = "LLVMConstMul"
external const_nsw_mul : llvalue -> llvalue -> llvalue = "LLVMConstNSWMul"
external const_nuw_mul : llvalue -> llvalue -> llvalue = "LLVMConstNUWMul"
external const_fmul : llvalue -> llvalue -> llvalue = "LLVMConstFMul"
external const_fdiv : llvalue -> llvalue -> llvalue = "LLVMConstFDiv"
external const_frem : llvalue -> llvalue -> llvalue = "LLVMConstFRem"
external const_and : llvalue -> llvalue -> llvalue = "LLVMConstAnd"
external const_or : llvalue -> llvalue -> llvalue = "LLVMConstOr"
external const_xor : llvalue -> llvalue -> llvalue = "LLVMConstXor"

22
llvm/bindings/ocaml/llvm/llvm.mli
View File

@ -1099,10 +1099,6 @@ val const_nsw_add : llvalue -> llvalue -> llvalue
See the method [llvm::ConstantExpr::getNSWAdd]. *)
val const_nuw_add : llvalue -> llvalue -> llvalue
(** [const_fadd c1 c2] returns the constant sum of two constant floats.
See the method [llvm::ConstantExpr::getFAdd]. *)
val const_fadd : llvalue -> llvalue -> llvalue
(** [const_sub c1 c2] returns the constant difference, [c1 - c2], of two
constants. See the method [llvm::ConstantExpr::getSub]. *)
val const_sub : llvalue -> llvalue -> llvalue
@ -1117,10 +1113,6 @@ val const_nsw_sub : llvalue -> llvalue -> llvalue
See the method [llvm::ConstantExpr::getNSWSub]. *)
val const_nuw_sub : llvalue -> llvalue -> llvalue
(** [const_fsub c1 c2] returns the constant difference, [c1 - c2], of two
constant floats. See the method [llvm::ConstantExpr::getFSub]. *)
val const_fsub : llvalue -> llvalue -> llvalue
(** [const_mul c1 c2] returns the constant product of two constants.
See the method [llvm::ConstantExpr::getMul]. *)
val const_mul : llvalue -> llvalue -> llvalue
@ -1135,20 +1127,6 @@ val const_nsw_mul : llvalue -> llvalue -> llvalue
See the method [llvm::ConstantExpr::getNSWMul]. *)
val const_nuw_mul : llvalue -> llvalue -> llvalue
(** [const_fmul c1 c2] returns the constant product of two constants floats.
See the method [llvm::ConstantExpr::getFMul]. *)
val const_fmul : llvalue -> llvalue -> llvalue
(** [const_fdiv c1 c2] returns the constant quotient [c1 / c2] of two floating
point constants.
See the method [llvm::ConstantExpr::getFDiv]. *)
val const_fdiv : llvalue -> llvalue -> llvalue
(** [const_frem c1 c2] returns the constant remainder [c1 MOD c2] of two
signed floating point constants.
See the method [llvm::ConstantExpr::getFRem]. *)
val const_frem : llvalue -> llvalue -> llvalue
(** [const_and c1 c2] returns the constant bitwise [AND] of two integer
constants.
See the method [llvm::ConstantExpr::getAnd]. *)

10
llvm/docs/ReleaseNotes.rst
View File

@ -76,6 +76,11 @@ Changes to the LLVM IR
* ``sdiv``
* ``urem``
* ``srem``
* ``fadd``
* ``fsub``
* ``fmul``
* ``fdiv``
* ``frem``
* Added the support for ``fmax`` and ``fmin`` in ``atomicrmw`` instruction. The
comparison is expected to match the behavior of ``llvm.maxnum.*`` and
``llvm.minnum.*`` respectively.
@ -198,6 +203,11 @@ Changes to the C API
* ``LLVMConstExactSDiv``
* ``LLVMConstURem``
* ``LLVMConstSRem``
* ``LLVMConstFAdd``
* ``LLVMConstFSub``
* ``LLVMConstFMul``
* ``LLVMConstFDiv``
* ``LLVMConstFRem``
* Add ``LLVMDeleteInstruction`` function which allows deleting instructions that
are not inserted into a basic block.

5
llvm/include/llvm-c/Core.h
View File

@ -2167,17 +2167,12 @@ LLVMValueRef LLVMConstNot(LLVMValueRef ConstantVal);
LLVMValueRef LLVMConstAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstNSWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstNSWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstNSWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstOr(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);
LLVMValueRef LLVMConstXor(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant);

5
llvm/include/llvm/IR/Constants.h
View File

@ -1017,15 +1017,10 @@ public:
static Constant *getNot(Constant *C);
static Constant *getAdd(Constant *C1, Constant *C2, bool HasNUW = false,
bool HasNSW = false);
static Constant *getFAdd(Constant *C1, Constant *C2);
static Constant *getSub(Constant *C1, Constant *C2, bool HasNUW = false,
bool HasNSW = false);
static Constant *getFSub(Constant *C1, Constant *C2);
static Constant *getMul(Constant *C1, Constant *C2, bool HasNUW = false,
bool HasNSW = false);
static Constant *getFMul(Constant *C1, Constant *C2);
static Constant *getFDiv(Constant *C1, Constant *C2);
static Constant *getFRem(Constant *C1, Constant *C2);
static Constant *getAnd(Constant *C1, Constant *C2);
static Constant *getOr(Constant *C1, Constant *C2);
static Constant *getXor(Constant *C1, Constant *C2);

15
llvm/lib/AsmParser/LLParser.cpp
View File

@ -3484,6 +3484,16 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS, Type *ExpectedTy) {
return error(ID.Loc, "urem constexprs are no longer supported");
case lltok::kw_srem:
return error(ID.Loc, "srem constexprs are no longer supported");
case lltok::kw_fadd:
return error(ID.Loc, "fadd constexprs are no longer supported");
case lltok::kw_fsub:
return error(ID.Loc, "fsub constexprs are no longer supported");
case lltok::kw_fmul:
return error(ID.Loc, "fmul constexprs are no longer supported");
case lltok::kw_fdiv:
return error(ID.Loc, "fdiv constexprs are no longer supported");
case lltok::kw_frem:
return error(ID.Loc, "frem constexprs are no longer supported");
case lltok::kw_icmp:
case lltok::kw_fcmp: {
unsigned PredVal, Opc = Lex.getUIntVal();
@ -3543,13 +3553,8 @@ bool LLParser::parseValID(ValID &ID, PerFunctionState *PFS, Type *ExpectedTy) {
}
// Binary Operators.
case lltok::kw_add:
case lltok::kw_fadd:
case lltok::kw_sub:
case lltok::kw_fsub:
case lltok::kw_mul:
case lltok::kw_fmul:
case lltok::kw_fdiv:
case lltok::kw_frem:
case lltok::kw_shl:
case lltok::kw_lshr:
case lltok::kw_ashr: {

30
llvm/lib/IR/Constants.cpp
View File

@ -2355,6 +2355,11 @@ bool ConstantExpr::isSupportedBinOp(unsigned Opcode) {
case Instruction::SDiv:
case Instruction::URem:
case Instruction::SRem:
case Instruction::FAdd:
case Instruction::FSub:
case Instruction::FMul:
case Instruction::FDiv:
case Instruction::FRem:
return false;
case Instruction::Add:
case Instruction::Sub:
@ -2365,11 +2370,6 @@ bool ConstantExpr::isSupportedBinOp(unsigned Opcode) {
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
case Instruction::FAdd:
case Instruction::FSub:
case Instruction::FMul:
case Instruction::FDiv:
case Instruction::FRem:
return true;
default:
llvm_unreachable("Argument must be binop opcode");
@ -2668,10 +2668,6 @@ Constant *ConstantExpr::getAdd(Constant *C1, Constant *C2,
return get(Instruction::Add, C1, C2, Flags);
}
Constant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) {
return get(Instruction::FAdd, C1, C2);
}
Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
bool HasNUW, bool HasNSW) {
unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
@ -2679,10 +2675,6 @@ Constant *ConstantExpr::getSub(Constant *C1, Constant *C2,
return get(Instruction::Sub, C1, C2, Flags);
}
Constant *ConstantExpr::getFSub(Constant *C1, Constant *C2) {
return get(Instruction::FSub, C1, C2);
}
Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
bool HasNUW, bool HasNSW) {
unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) |
@ -2690,18 +2682,6 @@ Constant *ConstantExpr::getMul(Constant *C1, Constant *C2,
return get(Instruction::Mul, C1, C2, Flags);
}
Constant *ConstantExpr::getFMul(Constant *C1, Constant *C2) {
return get(Instruction::FMul, C1, C2);
}
Constant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) {
return get(Instruction::FDiv, C1, C2);
}
Constant *ConstantExpr::getFRem(Constant *C1, Constant *C2) {
return get(Instruction::FRem, C1, C2);
}
Constant *ConstantExpr::getAnd(Constant *C1, Constant *C2) {
return get(Instruction::And, C1, C2);
}

25
llvm/lib/IR/Core.cpp
View File

@ -1574,11 +1574,6 @@ LLVMValueRef LLVMConstNUWAdd(LLVMValueRef LHSConstant,
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstFAdd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getFAdd(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getSub(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
@ -1596,11 +1591,6 @@ LLVMValueRef LLVMConstNUWSub(LLVMValueRef LHSConstant,
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstFSub(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getFSub(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getMul(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
@ -1618,21 +1608,6 @@ LLVMValueRef LLVMConstNUWMul(LLVMValueRef LHSConstant,
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstFMul(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getFMul(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstFDiv(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getFDiv(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstFRem(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getFRem(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));
}
LLVMValueRef LLVMConstAnd(LLVMValueRef LHSConstant, LLVMValueRef RHSConstant) {
return wrap(ConstantExpr::getAnd(unwrap<Constant>(LHSConstant),
unwrap<Constant>(RHSConstant)));

10
llvm/test/Bindings/OCaml/core.ml
View File

@ -244,17 +244,12 @@ let test_constants () =
* CHECK: @const_add = global i64 add
* CHECK: @const_nsw_add = global i64 add nsw
* CHECK: @const_nuw_add = global i64 add nuw
* CHECK: @const_fadd = global double fadd
* CHECK: @const_sub = global i64 sub
* CHECK: @const_nsw_sub = global i64 sub nsw
* CHECK: @const_nuw_sub = global i64 sub nuw
* CHECK: @const_fsub = global double fsub
* CHECK: @const_mul = global i64 mul
* CHECK: @const_nsw_mul = global i64 mul nsw
* CHECK: @const_nuw_mul = global i64 mul nuw
* CHECK: @const_fmul = global double fmul
* CHECK: @const_fdiv = global double fdiv
* CHECK: @const_frem = global double frem
* CHECK: @const_and = global i64 and
* CHECK: @const_or = global i64 or
* CHECK: @const_xor = global i64 xor
@ -275,17 +270,12 @@ let test_constants () =
ignore (define_global "const_add" (const_add foldbomb five) m);
ignore (define_global "const_nsw_add" (const_nsw_add foldbomb five) m);
ignore (define_global "const_nuw_add" (const_nuw_add foldbomb five) m);
ignore (define_global "const_fadd" (const_fadd ffoldbomb ffive) m);
ignore (define_global "const_sub" (const_sub foldbomb five) m);
ignore (define_global "const_nsw_sub" (const_nsw_sub foldbomb five) m);
ignore (define_global "const_nuw_sub" (const_nuw_sub foldbomb five) m);
ignore (define_global "const_fsub" (const_fsub ffoldbomb ffive) m);
ignore (define_global "const_mul" (const_mul foldbomb five) m);
ignore (define_global "const_nsw_mul" (const_nsw_mul foldbomb five) m);
ignore (define_global "const_nuw_mul" (const_nuw_mul foldbomb five) m);
ignore (define_global "const_fmul" (const_fmul ffoldbomb ffive) m);
ignore (define_global "const_fdiv" (const_fdiv ffoldbomb ffive) m);
ignore (define_global "const_frem" (const_frem ffoldbomb ffive) m);
ignore (define_global "const_and" (const_and foldbomb five) m);
ignore (define_global "const_or" (const_or foldbomb five) m);
ignore (define_global "const_xor" (const_xor foldbomb five) m);

5
llvm/test/CodeGen/AMDGPU/sched-crash-dbg-value.mir
View File

@ -124,7 +124,10 @@
%tmp93 = fmul float %tmp42, %tmp87
%tmp94 = call float @llvm.fmuladd.f32(float %tmp92, float %tmp36, float %tmp93)
%tmp95 = call float @llvm.fmuladd.f32(float %tmp48, float undef, float %tmp94)
%tmp96 = fsub float extractelement (<2 x float> fadd (<2 x float> fmul (<2 x float> undef, <2 x float> undef), <2 x float> undef), i64 1), %tmp95
%fmul = fmul <2 x float> undef, undef
%fadd = fadd <2 x float> %fmul, undef
%extractelement = extractelement <2 x float> %fadd, i64 1
%tmp96 = fsub float %extractelement, %tmp95
%tmp97 = getelementptr inbounds %struct.wombat, %struct.wombat addrspace(5)* %tmp5, i32 0, i32 8, i32 1
call void @func(float %tmp96, i64 0, i16 addrspace(5)* nonnull %tmp97) #3
%tmp984 = bitcast [16 x i8] addrspace(3)* %17 to i8 addrspace(3)*

3
llvm/test/CodeGen/AMDGPU/si-spill-cf.ll
View File

@ -88,7 +88,8 @@ LOOP: ; preds = %ENDIF2795, %main_bo
ENDLOOP: ; preds = %ELSE2566, %LOOP
%one.sub.a.i = fsub float 1.000000e+00, %tmp
%one.sub.ac.i = fmul float %one.sub.a.i, undef
%result.i = fadd float fmul (float undef, float undef), %one.sub.ac.i
%fmul = fmul float undef, undef
%result.i = fadd float %fmul, %one.sub.ac.i
call void @llvm.amdgcn.exp.f32(i32 0, i32 15, float undef, float %result.i, float undef, float 1.000000e+00, i1 true, i1 true) #0
ret void

9
llvm/test/CodeGen/PowerPC/2008-07-15-Fabs.ll
View File

@ -8,13 +8,14 @@ target triple = "powerpc64-unknown-linux-gnu"
define hidden i256 @__divtc3(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ppc_fp128 %d) nounwind readnone {
entry:
call ppc_fp128 @fabsl( ppc_fp128 %d ) nounwind readnone ; <ppc_fp128>:0 [#uses=1]
fcmp olt ppc_fp128 0xM00000000000000000000000000000000, %0 ; <i1>:1 [#uses=1]
%1 = fcmp olt ppc_fp128 0xM00000000000000000000000000000000, %0 ; <i1>:1 [#uses=1]
%.pn106 = select i1 %1, ppc_fp128 %a, ppc_fp128 0xM00000000000000000000000000000000 ; <ppc_fp128> [#uses=1]
%.pn = fsub ppc_fp128 0xM00000000000000000000000000000000, %.pn106 ; <ppc_fp128> [#uses=1]
%y.0 = fdiv ppc_fp128 %.pn, 0xM00000000000000000000000000000000 ; <ppc_fp128> [#uses=1]
fmul ppc_fp128 %y.0, 0xM3FF00000000000000000000000000000 ; <ppc_fp128>:2 [#uses=1]
fadd ppc_fp128 %2, fmul (ppc_fp128 0xM00000000000000000000000000000000, ppc_fp128 0xM00000000000000000000000000000000) ; <ppc_fp128>:3 [#uses=1]
%tmpi = fadd ppc_fp128 %3, 0xM00000000000000000000000000000000 ; <ppc_fp128> [#uses=1]
%2 = fmul ppc_fp128 %y.0, 0xM3FF00000000000000000000000000000 ; <ppc_fp128>:2 [#uses=1]
%fmul = fmul ppc_fp128 0xM00000000000000000000000000000000, 0xM00000000000000000000000000000000
%fadd = fadd ppc_fp128 %2, %fmul
%tmpi = fadd ppc_fp128 %fadd, 0xM00000000000000000000000000000000
store ppc_fp128 %tmpi, ppc_fp128* null, align 16
ret i256 0
}

3
llvm/test/CodeGen/X86/2011-02-23-UnfoldBug.ll
View File

@ -9,7 +9,8 @@ entry:
for.cond.outer: ; preds = %if.end71, %entry
%theta.0.ph = phi <2 x double> [ undef, %entry ], [ %theta.1, %if.end71 ]
%mul.i97 = fmul <2 x double> %theta.0.ph, undef
%mul.i96 = fmul <2 x double> %mul.i97, fmul (<2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double> undef)
%fmul = fmul <2 x double> <double 2.000000e+00, double 2.000000e+00>, undef
%mul.i96 = fmul <2 x double> %mul.i97, %fmul
br i1 undef, label %for.body, label %for.end82
for.body: ; preds = %for.cond.outer

18
llvm/test/CodeGen/X86/pr44749.ll
View File

@ -9,27 +9,29 @@ define i32 @a() {
; CHECK-NEXT: xorl %eax, %eax
; CHECK-NEXT: ## kill: def $al killed $al killed $eax
; CHECK-NEXT: callq _b
; CHECK-NEXT: cvtsi2sd %eax, %xmm0
; CHECK-NEXT: cvtsi2sd %eax, %xmm1
; CHECK-NEXT: movq _calloc@GOTPCREL(%rip), %rax
; CHECK-NEXT: subq $-1, %rax
; CHECK-NEXT: setne %al
; CHECK-NEXT: movzbl %al, %eax
; CHECK-NEXT: movl %eax, %ecx
; CHECK-NEXT: leaq {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %rax
; CHECK-NEXT: movsd {{.*#+}} xmm1 = mem[0],zero
; CHECK-NEXT: ucomisd %xmm1, %xmm0
; CHECK-NEXT: setae %al
; CHECK-NEXT: movzbl %al, %eax
; CHECK-NEXT: movl %eax, %ecx
; CHECK-NEXT: leaq {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %rax
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
; CHECK-NEXT: movsd {{.*#+}} xmm3 = mem[0],zero
; CHECK-NEXT: movsd {{.*#+}} xmm2 = mem[0],zero
; CHECK-NEXT: cmplesd %xmm1, %xmm0
; CHECK-NEXT: movaps %xmm0, %xmm1
; CHECK-NEXT: andpd %xmm3, %xmm1
; CHECK-NEXT: andnpd %xmm2, %xmm0
; CHECK-NEXT: orpd %xmm1, %xmm0
; CHECK-NEXT: cvttsd2si %xmm0, %eax
; CHECK-NEXT: popq %rcx
; CHECK-NEXT: retq
entry:
%call = call i32 (...) @b()
%conv = sitofp i32 %call to double
%cmp = fcmp ole double fsub (double sitofp (i32 select (i1 icmp ne (i8* (i64, i64)* bitcast (i8* getelementptr (i8, i8* bitcast (i8* (i64, i64)* @calloc to i8*), i64 1) to i8* (i64, i64)*), i8* (i64, i64)* null), i32 1, i32 0) to double), double 1.000000e+02), %conv
%fsub = fsub double sitofp (i32 select (i1 icmp ne (i8* (i64, i64)* bitcast (i8* getelementptr (i8, i8* bitcast (i8* (i64, i64)* @calloc to i8*), i64 1) to i8* (i64, i64)*), i8* (i64, i64)* null), i32 1, i32 0) to double), 1.000000e+02
%cmp = fcmp ole double %fsub, %conv
%cond = select i1 %cmp, double 1.000000e+00, double 3.140000e+00
%conv2 = fptosi double %cond to i32
ret i32 %conv2

6
llvm/test/DebugInfo/ARM/selectiondag-deadcode.ll
View File

@ -2,7 +2,11 @@
target triple = "thumbv7-apple-ios7.0.0"
%class.Matrix3.0.6.10 = type { [9 x float] }
define arm_aapcscc void @_Z9GetMatrixv(%class.Matrix3.0.6.10* noalias nocapture sret(%class.Matrix3.0.6.10) %agg.result) #0 !dbg !39 {
br i1 fcmp oeq (float fadd (float fadd (float fmul (float undef, float undef), float fmul (float undef, float undef)), float fmul (float undef, float undef)), float 0.000000e+00), label %_ZN7Vector39NormalizeEv.exit, label %1
%fmul = fmul float undef, undef
%fadd = fadd float %fmul, %fmul
%fadd2 = fadd float %fadd, %fmul
%fcmp = fcmp oeq float %fadd2, 0.000000e+00
br i1 %fcmp, label %_ZN7Vector39NormalizeEv.exit, label %1
tail call arm_aapcscc void @_ZL4Sqrtd() #3
br label %_ZN7Vector39NormalizeEv.exit
_ZN7Vector39NormalizeEv.exit: ; preds = %1, %0

12
llvm/test/Transforms/InstCombine/fma.ll
View File

@ -99,7 +99,8 @@ define float @fma_fneg_const_fneg_y(float %y, float %z) {
; CHECK-NEXT: ret float [[FMA]]
;
%y.fneg = fsub float -0.0, %y
%fma = call float @llvm.fma.f32(float fsub (float -0.0, float bitcast (i32 ptrtoint (i32* @external to i32) to float)), float %y.fneg, float %z)
%fsub = fsub float -0.0, bitcast (i32 ptrtoint (i32* @external to i32) to float)
%fma = call float @llvm.fma.f32(float %fsub, float %y.fneg, float %z)
ret float %fma
}
@ -119,7 +120,8 @@ define float @fma_fneg_x_fneg_const(float %x, float %z) {
; CHECK-NEXT: ret float [[FMA]]
;
%x.fneg = fsub float -0.0, %x
%fma = call float @llvm.fma.f32(float %x.fneg, float fsub (float -0.0, float bitcast (i32 ptrtoint (i32* @external to i32) to float)), float %z)
%fsub = fsub float -0.0, bitcast (i32 ptrtoint (i32* @external to i32) to float)
%fma = call float @llvm.fma.f32(float %x.fneg, float %fsub, float %z)
ret float %fma
}
@ -218,7 +220,8 @@ define float @fmuladd_fneg_const_fneg_y(float %y, float %z) {
; CHECK-NEXT: ret float [[FMULADD]]
;
%y.fneg = fsub float -0.0, %y
%fmuladd = call float @llvm.fmuladd.f32(float fsub (float -0.0, float bitcast (i32 ptrtoint (i32* @external to i32) to float)), float %y.fneg, float %z)
%fsub = fsub float -0.0, bitcast (i32 ptrtoint (i32* @external to i32) to float)
%fmuladd = call float @llvm.fmuladd.f32(float %fsub, float %y.fneg, float %z)
ret float %fmuladd
}
@ -238,7 +241,8 @@ define float @fmuladd_fneg_x_fneg_const(float %x, float %z) {
; CHECK-NEXT: ret float [[FMULADD]]
;
%x.fneg = fsub float -0.0, %x
%fmuladd = call float @llvm.fmuladd.f32(float %x.fneg, float fsub (float -0.0, float bitcast (i32 ptrtoint (i32* @external to i32) to float)), float %z)
%fsub = fsub float -0.0, bitcast (i32 ptrtoint (i32* @external to i32) to float)
%fmuladd = call float @llvm.fmuladd.f32(float %x.fneg, float %fsub, float %z)
ret float %fmuladd
}

5
llvm/test/Transforms/InstCombine/fmul.ll
View File

@ -1057,10 +1057,11 @@ define float @fmul_fdiv_factor_extra_use(float %x, float %y) {
define double @fmul_negated_constant_expression(double %x) {
; CHECK-LABEL: @fmul_negated_constant_expression(
; CHECK-NEXT: [[R:%.*]] = fmul double [[X:%.*]], fsub (double -0.000000e+00, double bitcast (i64 ptrtoint (i8** getelementptr inbounds ({ [2 x i8*] }, { [2 x i8*] }* @g, i64 0, inrange i32 0, i64 2) to i64) to double))
; CHECK-NEXT: [[R:%.*]] = fmul double [[X:%.*]], fneg (double bitcast (i64 ptrtoint (i8** getelementptr inbounds ({ [2 x i8*] }, { [2 x i8*] }* @g, i64 0, inrange i32 0, i64 2) to i64) to double))
; CHECK-NEXT: ret double [[R]]
;
%r = fmul double %x, fsub (double -0.000000e+00, double bitcast (i64 ptrtoint (i8** getelementptr inbounds ({ [2 x i8*] }, { [2 x i8*] }* @g, i64 0, inrange i32 0, i64 2) to i64) to double))
%fsub = fsub double -0.000000e+00, bitcast (i64 ptrtoint (i8** getelementptr inbounds ({ [2 x i8*] }, { [2 x i8*] }* @g, i64 0, inrange i32 0, i64 2) to i64) to double)
%r = fmul double %x, %fsub
ret double %r
}

9
llvm/test/Transforms/InstSimplify/ConstProp/bitcast.ll
View File

@ -17,9 +17,14 @@ define <1 x i64> @test1() {
define i1 @bad_icmp_constexpr_bitcast() {
; CHECK-LABEL: @bad_icmp_constexpr_bitcast(
; CHECK-NEXT: ret i1 icmp eq (i32 ptrtoint (ptr @a to i32), i32 bitcast (float fadd (float bitcast (i32 ptrtoint (ptr @b to i32) to float), float 2.000000e+00) to i32))
; CHECK-NEXT: [[FADD:%.*]] = fadd float bitcast (i32 ptrtoint (ptr @b to i32) to float), 2.000000e+00
; CHECK-NEXT: [[BITCAST:%.*]] = bitcast float [[FADD]] to i32
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 ptrtoint (ptr @a to i32), [[BITCAST]]
; CHECK-NEXT: ret i1 [[CMP]]
;
%cmp = icmp eq i32 ptrtoint (ptr @a to i32), bitcast (float fadd (float bitcast (i32 ptrtoint (ptr @b to i32) to float), float 2.0) to i32)
%fadd = fadd float bitcast (i32 ptrtoint (ptr @b to i32) to float), 2.0
%bitcast = bitcast float %fadd to i32
%cmp = icmp eq i32 ptrtoint (ptr @a to i32), %bitcast
ret i1 %cmp
}

7
llvm/test/Transforms/InstSimplify/ConstProp/constant-expr.ll
View File

@ -51,13 +51,6 @@
@T5 = global ptr inttoptr (i64 add (i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (ptr @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (ptr @A to i64) to i256), i256 192)), i256 192) to i64), i64 trunc (i256 lshr (i256 or (i256 and (i256 and (i256 shl (i256 zext (i64 ptrtoint (ptr @B to i64) to i256), i256 64), i256 -6277101735386680763495507056286727952638980837032266301441), i256 6277101735386680763835789423207666416102355444464034512895), i256 shl (i256 zext (i64 ptrtoint (ptr @A to i64) to i256), i256 192)), i256 128) to i64)) to ptr)
; PR6096
; No check line. This used to crash llvm-as.
@T6 = global <2 x i1> fcmp ole (<2 x float> fdiv (<2 x float> undef, <2 x float> <float 1.000000e+00, float 1.000000e+00>), <2 x float> zeroinitializer)
; PR9011
@pr9011_1 = constant <4 x i32> zext (<4 x i8> zeroinitializer to <4 x i32>)

9
llvm/test/Transforms/InstSimplify/fdiv.ll
View File

@ -50,3 +50,12 @@ define <2 x float> @fmul_fdiv_common_operand_commute_vec(<2 x float> %x, <2 x fl
ret <2 x float> %d
}
; The constant expression version of this used to crash llvm-as.
define <2 x i1> @pr6096() {
; CHECK-LABEL: @pr6096(
; CHECK-NEXT: ret <2 x i1> zeroinitializer
;
%fdiv = fdiv <2 x float> undef, <float 1.000000e+00, float 1.000000e+00>
%fcmp = fcmp ole <2 x float> %fdiv, zeroinitializer
ret <2 x i1> %fcmp
}

4
llvm/test/Transforms/LoopVectorize/scev-exitlim-crash.ll
View File

@ -18,7 +18,9 @@ entry:
for.cond: ; preds = %for.cond, %entry
%i.0 = phi i32 [ undef, %entry ], [ %inc, %for.cond ]
%cmp = icmp slt i32 %i.0, 0
%call = tail call i32 @fn2(double fadd (double fsub (double undef, double undef), double 1.000000e+00)) #2
%fsub = fsub double undef, undef
%fadd = fadd double %fsub, 1.000000e+00
%call = tail call i32 @fn2(double %fadd) #2
%inc = add nsw i32 %i.0, 1
br i1 %cmp, label %for.cond, label %for.cond4.preheader

5
llvm/unittests/IR/ConstantsTest.cpp
View File

@ -248,13 +248,8 @@ TEST(ConstantsTest, AsInstructionsTest) {
"add nsw i32 " P0STR ", " P0STR);
CHECK(ConstantExpr::getAdd(P0, P0, true, true),
"add nuw nsw i32 " P0STR ", " P0STR);
CHECK(ConstantExpr::getFAdd(P1, P1), "fadd float " P1STR ", " P1STR);
CHECK(ConstantExpr::getSub(P0, P0), "sub i32 " P0STR ", " P0STR);
CHECK(ConstantExpr::getFSub(P1, P1), "fsub float " P1STR ", " P1STR);
CHECK(ConstantExpr::getMul(P0, P0), "mul i32 " P0STR ", " P0STR);
CHECK(ConstantExpr::getFMul(P1, P1), "fmul float " P1STR ", " P1STR);
CHECK(ConstantExpr::getFDiv(P1, P1), "fdiv float " P1STR ", " P1STR);
CHECK(ConstantExpr::getFRem(P1, P1), "frem float " P1STR ", " P1STR);
CHECK(ConstantExpr::getAnd(P0, P0), "and i32 " P0STR ", " P0STR);
CHECK(ConstantExpr::getOr(P0, P0), "or i32 " P0STR ", " P0STR);
CHECK(ConstantExpr::getXor(P0, P0), "xor i32 " P0STR ", " P0STR);