[llvm] 4c3e25d - [Annotation2Metadata] Support opaque pointers

[Nikita Popov via llvm-commits]

Author: Nikita Popov
Date: 2023-01-04T16:21:56+01:00
New Revision: 4c3e25d380b946374cb7d47616dddf4bb854fb5e

URL: https://github.com/llvm/llvm-project/commit/4c3e25d380b946374cb7d47616dddf4bb854fb5e
DIFF: https://github.com/llvm/llvm-project/commit/4c3e25d380b946374cb7d47616dddf4bb854fb5e.diff

LOG: [Annotation2Metadata] Support opaque pointers

Strip pointer casts instead of matching specific constant
expressions.

Added: 
    

Modified: 
    llvm/lib/Transforms/IPO/Annotation2Metadata.cpp
    llvm/test/Transforms/Util/annotation2metadata.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Transforms/IPO/Annotation2Metadata.cpp b/llvm/lib/Transforms/IPO/Annotation2Metadata.cpp
index 5ca4e24df8fce..6cc04544cabc5 100644
--- a/llvm/lib/Transforms/IPO/Annotation2Metadata.cpp
+++ b/llvm/lib/Transforms/IPO/Annotation2Metadata.cpp
@@ -47,20 +47,13 @@ static bool convertAnnotation2Metadata(Module &M) {
     auto *OpC = dyn_cast<ConstantStruct>(&Op);
     if (!OpC || OpC->getNumOperands() != 4)
       continue;
-    auto *StrGEP = dyn_cast<ConstantExpr>(OpC->getOperand(1));
-    if (!StrGEP || StrGEP->getNumOperands() < 2)
-      continue;
-    auto *StrC = dyn_cast<GlobalValue>(StrGEP->getOperand(0));
+    auto *StrC = dyn_cast<GlobalValue>(OpC->getOperand(1)->stripPointerCasts());
     if (!StrC)
       continue;
     auto *StrData = dyn_cast<ConstantDataSequential>(StrC->getOperand(0));
     if (!StrData)
       continue;
-    // Look through bitcast.
-    auto *Bitcast = dyn_cast<ConstantExpr>(OpC->getOperand(0));
-    if (!Bitcast || Bitcast->getOpcode() != Instruction::BitCast)
-      continue;
-    auto *Fn = dyn_cast<Function>(Bitcast->getOperand(0));
+    auto *Fn = dyn_cast<Function>(OpC->getOperand(0)->stripPointerCasts());
     if (!Fn)
       continue;
 

diff  --git a/llvm/test/Transforms/Util/annotation2metadata.ll b/llvm/test/Transforms/Util/annotation2metadata.ll
index 35ec3e75559fb..b4c70d2015aca 100644
--- a/llvm/test/Transforms/Util/annotation2metadata.ll
+++ b/llvm/test/Transforms/Util/annotation2metadata.ll
@@ -4,55 +4,55 @@
 @.str = private unnamed_addr constant [10 x i8] c"_remarks1\00", section "llvm.metadata"
 @.str.1 = private unnamed_addr constant [6 x i8] c"ann.c\00", section "llvm.metadata"
 @.str.2 = private unnamed_addr constant [10 x i8] c"_remarks2\00", section "llvm.metadata"
- at llvm.global.annotations = appending global [8 x { i8*, i8*, i8*, i32 }] [
-    { i8*, i8*, i8*, i32 } { i8* bitcast (void (float*)* @test1 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i32 2 },
-    { i8*, i8*, i8*, i32 } { i8* bitcast (void (float*)* @test1 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i32 2 },
-    { i8*, i8*, i8*, i32 } { i8* bitcast (void (float*)* @test3 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* undef, i32 4 }, ; Invalid entry, make sure we do not crash.
-    { i8*, i8*, i8*, i32 } { i8* bitcast (void (float*)* @test3 to i8*), i8* undef, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i32 4 }, ; Invalid entry, make sure we do not crash.
-    { i8*, i8*, i8*, i32 } { i8* undef, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i32 4 }, ; Invalid entry, make sure we do not crash.
-    { i8*, i8*, i8*, i32 } { i8* bitcast (void (float*)* undef to i8*), i8* undef, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i32 4 }, ; Invalid entry, make sure we do not crash.
-    { i8*, i8*, i8*, i32 } { i8* undef, i8* undef, i8* undef, i32 300 },  ; Invalid entry, make sure we do not crash.
-    { i8*, i8*, i8*, i32 } { i8* bitcast (void (float*)* @test3 to i8*), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0), i32 4 }
+ at llvm.global.annotations = appending global [8 x { ptr, ptr, ptr, i32 }] [
+    { ptr, ptr, ptr, i32 } { ptr @test1, ptr @.str, ptr @.str.1, i32 2 },
+    { ptr, ptr, ptr, i32 } { ptr @test1, ptr @.str.2, ptr @.str.1, i32 2 },
+    { ptr, ptr, ptr, i32 } { ptr @test3, ptr @.str, ptr undef, i32 4 }, ; Invalid entry, make sure we do not crash.
+    { ptr, ptr, ptr, i32 } { ptr @test3, ptr undef, ptr @.str.1, i32 4 }, ; Invalid entry, make sure we do not crash.
+    { ptr, ptr, ptr, i32 } { ptr undef, ptr @.str, ptr @.str.1, i32 4 }, ; Invalid entry, make sure we do not crash.
+    { ptr, ptr, ptr, i32 } { ptr undef, ptr undef, ptr @.str.1, i32 4 }, ; Invalid entry, make sure we do not crash.
+    { ptr, ptr, ptr, i32 } { ptr undef, ptr undef, ptr undef, i32 300 },  ; Invalid entry, make sure we do not crash.
+    { ptr, ptr, ptr, i32 } { ptr @test3, ptr @.str, ptr @.str.1, i32 4 }
     ], section "llvm.metadata"
 
 
 
-define void @test1(float* %a) {
+define void @test1(ptr %a) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca float*, align 8, !annotation [[GROUP1:!.+]]
-; CHECK-NEXT:    store float* [[A:%.*]], float** [[A_ADDR]], align 8, !annotation [[GROUP1]]
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8, !annotation [[GROUP1:!.+]]
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8, !annotation [[GROUP1]]
 ; CHECK-NEXT:    ret void, !annotation [[GROUP1]]
 ;
 entry:
-  %a.addr = alloca float*, align 8
-  store float* %a, float** %a.addr, align 8
+  %a.addr = alloca ptr, align 8
+  store ptr %a, ptr %a.addr, align 8
   ret void
 }
 
-define void @test2(float* %a) {
+define void @test2(ptr %a) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca float*, align 8
-; CHECK-NEXT:    store float* [[A:%.*]], float** [[A_ADDR]], align 8
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8
 ; CHECK-NEXT:    ret void
 ;
 entry:
-  %a.addr = alloca float*, align 8
-  store float* %a, float** %a.addr, align 8
+  %a.addr = alloca ptr, align 8
+  store ptr %a, ptr %a.addr, align 8
   ret void
 }
 
-define void @test3(float* %a) {
+define void @test3(ptr %a) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca float*, align 8, !annotation [[GROUP2:!.+]]
-; CHECK-NEXT:    store float* [[A:%.*]], float** [[A_ADDR]], align 8, !annotation [[GROUP2]]
+; CHECK-NEXT:    [[A_ADDR:%.*]] = alloca ptr, align 8, !annotation [[GROUP2:!.+]]
+; CHECK-NEXT:    store ptr [[A:%.*]], ptr [[A_ADDR]], align 8, !annotation [[GROUP2]]
 ; CHECK-NEXT:    ret void, !annotation [[GROUP2]]
 ;
 entry:
-  %a.addr = alloca float*, align 8
-  store float* %a, float** %a.addr, align 8
+  %a.addr = alloca ptr, align 8
+  store ptr %a, ptr %a.addr, align 8
   ret void
 }