[llvm] 62e46f2 - [LLVM] Remove support for constant scalable vector GEPs.
Paul Walker via llvm-commits
llvm-commits at lists.llvm.org
Tue Mar 14 09:51:12 PDT 2023
Author: Paul Walker
Date: 2023-03-14T16:48:33Z
New Revision: 62e46f262158e2a6ea9c1c458f52633bb40a8590
URL: https://github.com/llvm/llvm-project/commit/62e46f262158e2a6ea9c1c458f52633bb40a8590
DIFF: https://github.com/llvm/llvm-project/commit/62e46f262158e2a6ea9c1c458f52633bb40a8590.diff
LOG: [LLVM] Remove support for constant scalable vector GEPs.
This work has fallen out from D134648 as a requirement to loosen
the "constness" of vscale.
Differential Revision: https://reviews.llvm.org/D145404
Added:
Modified:
llvm/include/llvm/Analysis/TargetFolder.h
llvm/include/llvm/IR/ConstantFolder.h
llvm/include/llvm/IR/Constants.h
llvm/lib/Analysis/ConstantFolding.cpp
llvm/lib/Analysis/InstructionSimplify.cpp
llvm/lib/Bitcode/Reader/BitcodeReader.cpp
llvm/lib/IR/Constants.cpp
llvm/test/Bitcode/constexpr-scalable-vector-gep.ll
llvm/test/CodeGen/AArch64/sve-vscale.ll
llvm/test/Transforms/InstSimplify/ConstProp/vscale-inseltpoison.ll
llvm/test/Transforms/InstSimplify/ConstProp/vscale.ll
llvm/test/Transforms/InstSimplify/vscale-inseltpoison.ll
llvm/test/Transforms/InstSimplify/vscale.ll
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/TargetFolder.h b/llvm/include/llvm/Analysis/TargetFolder.h
index 51f457ddb529a..3d9edf132dc10 100644
--- a/llvm/include/llvm/Analysis/TargetFolder.h
+++ b/llvm/include/llvm/Analysis/TargetFolder.h
@@ -116,6 +116,9 @@ class TargetFolder final : public IRBuilderFolder {
Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
bool IsInBounds = false) const override {
+ if (!ConstantExpr::isSupportedGetElementPtr(Ty))
+ return nullptr;
+
if (auto *PC = dyn_cast<Constant>(Ptr)) {
// Every index must be constant.
if (any_of(IdxList, [](Value *V) { return !isa<Constant>(V); }))
diff --git a/llvm/include/llvm/IR/ConstantFolder.h b/llvm/include/llvm/IR/ConstantFolder.h
index 4473187a1bf93..56da3d205fe4b 100644
--- a/llvm/include/llvm/IR/ConstantFolder.h
+++ b/llvm/include/llvm/IR/ConstantFolder.h
@@ -105,6 +105,9 @@ class ConstantFolder final : public IRBuilderFolder {
Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
bool IsInBounds = false) const override {
+ if (!ConstantExpr::isSupportedGetElementPtr(Ty))
+ return nullptr;
+
if (auto *PC = dyn_cast<Constant>(Ptr)) {
// Every index must be constant.
if (any_of(IdxList, [](Value *V) { return !isa<Constant>(V); }))
diff --git a/llvm/include/llvm/IR/Constants.h b/llvm/include/llvm/IR/Constants.h
index b5e68054a1aea..e82c6a8e1eab6 100644
--- a/llvm/include/llvm/IR/Constants.h
+++ b/llvm/include/llvm/IR/Constants.h
@@ -1349,6 +1349,12 @@ class ConstantExpr : public Constant {
/// supported.
static bool isSupportedBinOp(unsigned Opcode);
+ /// Whether creating a constant expression for this getelementptr type is
+ /// supported.
+ static bool isSupportedGetElementPtr(const Type *SrcElemTy) {
+ return !SrcElemTy->isScalableTy();
+ }
+
/// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Value *V) {
return V->getValueID() == ConstantExprVal;
diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp
index 76223f353288c..be409f62c50d7 100644
--- a/llvm/lib/Analysis/ConstantFolding.cpp
+++ b/llvm/lib/Analysis/ConstantFolding.cpp
@@ -1052,11 +1052,15 @@ Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode,
return ConstantFoldCastOperand(Opcode, Ops[0], DestTy, DL);
if (auto *GEP = dyn_cast<GEPOperator>(InstOrCE)) {
+ Type *SrcElemTy = GEP->getSourceElementType();
+ if (!ConstantExpr::isSupportedGetElementPtr(SrcElemTy))
+ return nullptr;
+
if (Constant *C = SymbolicallyEvaluateGEP(GEP, Ops, DL, TLI))
return C;
- return ConstantExpr::getGetElementPtr(GEP->getSourceElementType(), Ops[0],
- Ops.slice(1), GEP->isInBounds(),
+ return ConstantExpr::getGetElementPtr(SrcElemTy, Ops[0], Ops.slice(1),
+ GEP->isInBounds(),
GEP->getInRangeIndex());
}
diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp
index c57a111a5e204..ebc5a77efd1f7 100644
--- a/llvm/lib/Analysis/InstructionSimplify.cpp
+++ b/llvm/lib/Analysis/InstructionSimplify.cpp
@@ -4932,6 +4932,10 @@ static Value *simplifyGEPInst(Type *SrcTy, Value *Ptr,
!all_of(Indices, [](Value *V) { return isa<Constant>(V); }))
return nullptr;
+ if (!ConstantExpr::isSupportedGetElementPtr(SrcTy))
+ return ConstantFoldGetElementPtr(SrcTy, cast<Constant>(Ptr), InBounds,
+ std::nullopt, Indices);
+
auto *CE = ConstantExpr::getGetElementPtr(SrcTy, cast<Constant>(Ptr), Indices,
InBounds);
return ConstantFoldConstant(CE, Q.DL);
diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
index 2c1f195119bcc..dd75542164d38 100644
--- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1399,7 +1399,9 @@ unsigned BitcodeReader::getVirtualTypeID(Type *Ty,
return TypeID;
}
-static bool isConstExprSupported(uint8_t Opcode) {
+static bool isConstExprSupported(const BitcodeConstant *BC) {
+ uint8_t Opcode = BC->Opcode;
+
// These are not real constant expressions, always consider them supported.
if (Opcode >= BitcodeConstant::FirstSpecialOpcode)
return true;
@@ -1412,6 +1414,9 @@ static bool isConstExprSupported(uint8_t Opcode) {
if (Instruction::isBinaryOp(Opcode))
return ConstantExpr::isSupportedBinOp(Opcode);
+ if (Opcode == Instruction::GetElementPtr)
+ return ConstantExpr::isSupportedGetElementPtr(BC->SrcElemTy);
+
return Opcode != Instruction::FNeg;
}
@@ -1467,7 +1472,7 @@ Expected<Value *> BitcodeReader::materializeValue(unsigned StartValID,
ConstOps.push_back(C);
// Materialize as constant expression if possible.
- if (isConstExprSupported(BC->Opcode) && ConstOps.size() == Ops.size()) {
+ if (isConstExprSupported(BC) && ConstOps.size() == Ops.size()) {
Constant *C;
if (Instruction::isCast(BC->Opcode)) {
C = UpgradeBitCastExpr(BC->Opcode, ConstOps[0], BC->getType());
diff --git a/llvm/lib/IR/Constants.cpp b/llvm/lib/IR/Constants.cpp
index 6a6209c37d393..9348d1af65a4f 100644
--- a/llvm/lib/IR/Constants.cpp
+++ b/llvm/lib/IR/Constants.cpp
@@ -2464,6 +2464,7 @@ Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
Type *OnlyIfReducedTy) {
PointerType *OrigPtrTy = cast<PointerType>(C->getType()->getScalarType());
assert(Ty && "Must specify element type");
+ assert(isSupportedGetElementPtr(Ty) && "Element type is unsupported!");
assert(OrigPtrTy->isOpaqueOrPointeeTypeMatches(Ty));
if (Constant *FC =
diff --git a/llvm/test/Bitcode/constexpr-scalable-vector-gep.ll b/llvm/test/Bitcode/constexpr-scalable-vector-gep.ll
index edcb4773e4166..df660b5812163 100644
--- a/llvm/test/Bitcode/constexpr-scalable-vector-gep.ll
+++ b/llvm/test/Bitcode/constexpr-scalable-vector-gep.ll
@@ -1,5 +1,4 @@
-; RUN: llvm-as < %s | llvm-dis -expand-constant-exprs | FileCheck %s
-; RUN: llvm-dis -expand-constant-exprs < %s.bc | FileCheck %s
+; RUN: llvm-dis < %s.bc | FileCheck %s
@g = extern_weak global [32 x i8]
diff --git a/llvm/test/CodeGen/AArch64/sve-vscale.ll b/llvm/test/CodeGen/AArch64/sve-vscale.ll
index aa24a111036cf..3f2f5e6e3136d 100644
--- a/llvm/test/CodeGen/AArch64/sve-vscale.ll
+++ b/llvm/test/CodeGen/AArch64/sve-vscale.ll
@@ -46,7 +46,10 @@ define i64 @rdvl_i64() nounwind {
; CHECK: rdvl x0, #1
; CHECK-NEXT: ret
define i32 @rdvl_const() nounwind {
- ret i32 mul nsw (i32 ptrtoint (<vscale x 1 x i8>* getelementptr (<vscale x 1 x i8>, <vscale x 1 x i8>* null, i64 1) to i32), i32 16)
+ %vscale.ptr = getelementptr <vscale x 1 x i8>, ptr null, i64 1
+ %vscale.int = ptrtoint ptr %vscale.ptr to i32
+ %vscale.scaled = mul nsw i32 %vscale.int, 16
+ ret i32 %vscale.scaled
}
define i32 @vscale_1() nounwind {
diff --git a/llvm/test/Transforms/InstSimplify/ConstProp/vscale-inseltpoison.ll b/llvm/test/Transforms/InstSimplify/ConstProp/vscale-inseltpoison.ll
index b5bdbfcf24d82..63b9e12abfde5 100644
--- a/llvm/test/Transforms/InstSimplify/ConstProp/vscale-inseltpoison.ll
+++ b/llvm/test/Transforms/InstSimplify/ConstProp/vscale-inseltpoison.ll
@@ -202,19 +202,6 @@ define <vscale x 4 x i32> @shufflevector() {
ret <vscale x 4 x i32> %i2
}
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Memory Access and Addressing Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-define <vscale x 2 x double> @load() {
-; CHECK-LABEL: @load(
-; CHECK-NEXT: [[R:%.*]] = load <vscale x 2 x double>, ptr getelementptr (<vscale x 2 x double>, ptr null, i64 1), align 16
-; CHECK-NEXT: ret <vscale x 2 x double> [[R]]
-;
- %r = load <vscale x 2 x double>, ptr getelementptr (<vscale x 2 x double>, ptr null, i64 1)
- ret <vscale x 2 x double> %r
-}
-
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Conversion Operations
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/llvm/test/Transforms/InstSimplify/ConstProp/vscale.ll b/llvm/test/Transforms/InstSimplify/ConstProp/vscale.ll
index 0d597939cd13d..585e736650b78 100644
--- a/llvm/test/Transforms/InstSimplify/ConstProp/vscale.ll
+++ b/llvm/test/Transforms/InstSimplify/ConstProp/vscale.ll
@@ -202,19 +202,6 @@ define <vscale x 4 x i32> @shufflevector() {
ret <vscale x 4 x i32> %i2
}
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Memory Access and Addressing Operations
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-define <vscale x 2 x double> @load() {
-; CHECK-LABEL: @load(
-; CHECK-NEXT: [[R:%.*]] = load <vscale x 2 x double>, ptr getelementptr (<vscale x 2 x double>, ptr null, i64 1), align 16
-; CHECK-NEXT: ret <vscale x 2 x double> [[R]]
-;
- %r = load <vscale x 2 x double>, ptr getelementptr (<vscale x 2 x double>, ptr null, i64 1)
- ret <vscale x 2 x double> %r
-}
-
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Conversion Operations
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/llvm/test/Transforms/InstSimplify/vscale-inseltpoison.ll b/llvm/test/Transforms/InstSimplify/vscale-inseltpoison.ll
index 7d4a7c2e6c3a7..5b34f417e4093 100644
--- a/llvm/test/Transforms/InstSimplify/vscale-inseltpoison.ll
+++ b/llvm/test/Transforms/InstSimplify/vscale-inseltpoison.ll
@@ -152,51 +152,6 @@ define <vscale x 4 x float> @bitcast() {
;; Memory Access and Addressing Operations
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; getelementptr
-
-define <vscale x 4 x ptr> @getelementptr_constant_foldable_1() {
-; CHECK-LABEL: @getelementptr_constant_foldable_1(
-; CHECK-NEXT: ret <vscale x 4 x ptr> zeroinitializer
-;
- %ptr = getelementptr i32, <vscale x 4 x ptr> zeroinitializer, <vscale x 4 x i64> undef
- ret <vscale x 4 x ptr> %ptr
-}
-
-define <vscale x 4 x ptr> @getelementptr_constant_foldable_2() {
-; CHECK-LABEL: @getelementptr_constant_foldable_2(
-; CHECK-NEXT: ret <vscale x 4 x ptr> zeroinitializer
-;
- %ptr = getelementptr <vscale x 4 x i32>, ptr null, <vscale x 4 x i64> undef
- ret <vscale x 4 x ptr> %ptr
-}
-
-; fold getelementptr P, 0 -> P.
-define ptr @getelementptr_constant_foldable_3() {
-; CHECK-LABEL: @getelementptr_constant_foldable_3(
-; CHECK-NEXT: ret ptr null
-;
- ret ptr null
-}
-
-define ptr @getelementptr_not_constant_foldable(i64 %x) {
-; CHECK-LABEL: @getelementptr_not_constant_foldable(
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr <vscale x 4 x i32>, ptr null, i64 [[X:%.*]]
-; CHECK-NEXT: ret ptr [[PTR]]
-;
- %ptr = getelementptr <vscale x 4 x i32>, ptr null, i64 %x
- ret ptr %ptr
-}
-
-; Check GEP's result is known to be non-null.
-define i1 @getelementptr_check_non_null(ptr %ptr) {
-; CHECK-LABEL: @getelementptr_check_non_null(
-; CHECK-NEXT: ret i1 false
-;
- %x = getelementptr inbounds <vscale x 16 x i8>, ptr %ptr, i32 1
- %cmp = icmp eq ptr %x, null
- ret i1 %cmp
-}
-
define i32 @extractelement_splat_constant_index(i32 %v) {
; CHECK-LABEL: @extractelement_splat_constant_index(
; CHECK-NEXT: ret i32 [[V:%.*]]
diff --git a/llvm/test/Transforms/InstSimplify/vscale.ll b/llvm/test/Transforms/InstSimplify/vscale.ll
index 47d281ea2d46d..66f629aac3a52 100644
--- a/llvm/test/Transforms/InstSimplify/vscale.ll
+++ b/llvm/test/Transforms/InstSimplify/vscale.ll
@@ -192,10 +192,10 @@ define ptr @getelementptr_constant_foldable_3() {
define ptr @getelementptr_not_constant_foldable(i64 %x) {
; CHECK-LABEL: @getelementptr_not_constant_foldable(
-; CHECK-NEXT: [[PTR:%.*]] = getelementptr <vscale x 4 x i32>, ptr null, i64 [[X:%.*]]
+; CHECK-NEXT: [[PTR:%.*]] = getelementptr <vscale x 4 x i32>, ptr null, i64 1
; CHECK-NEXT: ret ptr [[PTR]]
;
- %ptr = getelementptr <vscale x 4 x i32>, ptr null, i64 %x
+ %ptr = getelementptr <vscale x 4 x i32>, ptr null, i64 1
ret ptr %ptr
}
More information about the llvm-commits
mailing list