[IR] Support named struct result in intrinsic remangling

[nikic]

Summary

When an intrinsic is remangled, we currently try to replace with the canonical declaration. Unfortunately there is a quirk that makes intrinsic declarations in LLVM non-unique: For intrinsics with struct return type, the canonical declaration returns an unnamed struct, but LLVM also accepts named structs of equivalent structure. This "feature" is in active use by some target intrinsics.

As such, when we remangle an intrinsic we should use the original function type and just assign the new remangled name. matchIntrinsicSignature() has already checked that the function signature is valid.

This is not directly related to opaque pointers, but opaque pointer autoupgrade needs to remangle all intrinsics involving pointers, which is why we're hitting this issue now.

[aeubanks]

we might be able to stop supporting this "feature" but it'd require some work in the bitcode reader

[nikic]

In D122376#3406046, @aeubanks wrote:

we might be able to stop supporting this "feature" but it'd require some work in the bitcode reader

I looked into this, and it turned out to be easier than I expected: D122471 Might make sense to go directly with that variant.

[nikic]

Abandoning in favor of D122471.

llvm/lib/IR/Function.cpp

if (auto *ExistingGV = F->getParent()->getNamedValue(WantedName)) {
           return ExistingF;
 
       // The name already exists, but is not a function or has the wrong
       // prototype. Make place for the new one by renaming the old version.
       // Either this old version will be removed later on or the module is
       // invalid and we'll get an error.
       ExistingGV->setName(WantedName + ".renamed");
     }
-    return Intrinsic::getDeclaration(F->getParent(), ID, ArgTys);
+    return cast<Function>(
+        F->getParent()
+            ->getOrInsertFunction(WantedName, F->getFunctionType())
+            .getCallee());
   }();
 
   NewDecl->setCallingConv(F->getCallingConv());
   assert(NewDecl->getFunctionType() == F->getFunctionType() &&
          "Shouldn't change the signature");
   return NewDecl;
 }
 

llvm/test/Assembler/opaque-ptr-intrinsic-remangling.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -opaque-pointers < %s | FileCheck %s
 
 ; Make sure that opaque pointer intrinsic remangling upgrade works.
 
+%struct.__neon_int8x8x2_t = type { <8 x i8>, <8 x i8> }
+
 declare i32* @fake_personality_function()
 declare void @func()
 
 ; Upgrading of invoked intrinsic.
 define void @test_invoke(i32 addrspace(1)* %b) gc "statepoint-example" personality i32* ()* @fake_personality_function {
 ; CHECK-LABEL: @test_invoke(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[D:%.*]] = getelementptr i32, ptr addrspace(1) [[B:%.*]], i64 16

 ; CHECK-LABEL: @test_ptr_annotation(
 ; CHECK-NEXT:    [[P2:%.*]] = call ptr @llvm.ptr.annotation.p0(ptr [[P:%.*]], ptr undef, ptr undef, i32 undef, ptr undef)
 ; CHECK-NEXT:    ret ptr [[P2]]
 ;
   %p2 = call i8* @llvm.ptr.annotation.p0i8(i8* %p, i8* undef, i8* undef, i32 undef, i8* undef)
   ret i8* %p2
 }
 
+define %struct.__neon_int8x8x2_t @test_named_struct_return(i8* %A) {
+; CHECK-LABEL: @test_named_struct_return(
+; CHECK-NEXT:    [[VAL:%.*]] = call [[STRUCT___NEON_INT8X8X2_T:%.*]] @llvm.aarch64.neon.ld2.v8i8.p0(ptr [[A:%.*]])
+; CHECK-NEXT:    ret [[STRUCT___NEON_INT8X8X2_T]] [[VAL]]
+;
+  %val = call %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld2.v8i8.p0i8(i8* %A)
+  ret %struct.__neon_int8x8x2_t %val
+}
+
 declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
 declare i8* @llvm.ptr.annotation.p0i8(i8*, i8*, i8*, i32, i8*)
+declare %struct.__neon_int8x8x2_t @llvm.aarch64.neon.ld2.v8i8.p0i8(i8*)