inline global alias

[yaxunl]

Summary

Currently, llvm does not inline functions called through alias.
This causes performance degradation on Windows compared
with Linux, since on Windows some constructors are emitted
as aliases to other constructors.

This patch allows functions called through alias to be inlined.

[tra]

llvm/include/llvm/IR/InstrTypes.h

1409

Are we sure that there are no users of these getCalledFunction functions that would expect them to return nullptr when we deal with an alias?

Unless someone familiar with the code says that it's OK to treat aliases as functions here, I would try to keep effect of the change limited to the area where we're making a decision to inline the function or alias.

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

364

The fact that aliases were mentioned in this assertion make me wonder if there is a reason aliases are not inlined that I'm not aware of.

I'm out of my depth here, and would like to hear from someone who may know what's going on.

[arsenm]

I thought calls to aliases were generally folded to direct calls at some point, so is there just an ordering issue?

llvm/include/llvm/IR/InstrTypes.h

1409

I do think getCalledFunction is a hazardous function where most users do the wrong thing. This will continue to miss constantexpr casts. Could also stripPointerCastsAndAliases. I'm not sure if we want to change this or not

[yaxunl]

In D147022#4228170, @arsenm wrote:

I thought calls to aliases were generally folded to direct calls at some point, so is there just an ordering issue?

I searched references of GlobalAlias in LLVM code and could not find a pass doing that.

llvm/include/llvm/IR/InstrTypes.h

1409

I checked the references of getCalledFunction. It seems most cases they do not care whether a function is called through alias. However, there are situations where alias may be different from its aliasee.

I could add an optional parameter AllowAlias to getCalledFunction and by default off. Then turn it on where it makes sense.

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

364

I checked alias definition in LLVM manual (https://llvm.org/docs/LangRef.html#aliases). It seems to me the only situation we cannot inline an alias is when it has an optional weak linkage whereas the aliasee does not. Otherwise the alias and the aliasee is equivalent to the inliner.

I added more reviewers in the hope that we can get an answer why alias cannot be inlined.

[asl]

llvm/include/llvm/IR/AbstractCallSite.h

225

If an alias has weak linkage, then it could be overridden by a strong definition. So you cannot resolve alias to aliasee in such case. Same for the case below

[nikic]

Adding @pcc for alias optimizations.

llvm/include/llvm/IR/InstrTypes.h

1409

getCalledFunction() is explicitly not supposed to look through bitcasts, let alone aliases. Use getCalledOperand()->stripPointerCastsAndAliases() in places where you think stripping aliases is safe.

llvm/include/llvm/IR/AbstractCallSite.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_ABSTRACTCALLSITE_H
 #define LLVM_IR_ABSTRACTCALLSITE_H
 
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Value.h"
 #include <cassert>
 
 namespace llvm {
 
 class Argument;
 class Use;
if (isDirectCall())
       return CB->getCalledOperand();
     return CB->getArgOperand(getCallArgOperandNoForCallee());
   }
 
   /// Return the function being called if this is a direct call, otherwise
   /// return null (if it's an indirect call).
   Function *getCalledFunction() const {
     Value *V = getCalledOperand();
-    return V ? dyn_cast<Function>(V->stripPointerCasts()) : nullptr;
+    if (!V)
+      return nullptr;
+    V = V->stripPointerCasts();
+    if (auto *A = dyn_cast<GlobalAlias>(V))
+      return dyn_cast<Function>(A->getAliasee());
+    return dyn_cast<Function>(V);
   }
 };
 
 /// Apply function Func to each CB's callback call site.
 template <typename UnaryFunction>
 void forEachCallbackCallSite(const CallBase &CB, UnaryFunction Func) {
   SmallVector<const Use *, 4u> CallbackUses;
   AbstractCallSite::getCallbackUses(CB, CallbackUses);

llvm/include/llvm/IR/InstrTypes.h

 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
+#include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/User.h"
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
public:
 
   Value *getCalledOperand() const { return Op<CalledOperandOpEndIdx>(); }
 
   const Use &getCalledOperandUse() const { return Op<CalledOperandOpEndIdx>(); }
   Use &getCalledOperandUse() { return Op<CalledOperandOpEndIdx>(); }
 
   /// Returns the function called, or null if this is an indirect function
   /// invocation or the function signature does not match the call signature.
   Function *getCalledFunction() const {
-    if (auto *F = dyn_cast_or_null<Function>(getCalledOperand()))
+    Value *V = getCalledOperand();
+    if (!V)
+      return nullptr;
+    if (auto *A = dyn_cast<GlobalAlias>(V))
+      V = A->getAliasee();
+
+    if (auto *F = dyn_cast<Function>(V))
       if (F->getValueType() == getFunctionType())
         return F;
     return nullptr;
   }
 
   /// Return true if the callsite is an indirect call.
   bool isIndirectCall() const;
 

llvm/lib/Analysis/ModuleSummaryAnalysis.cpp

for (const Instruction &I : BB) {
       if (CalledValue && !CalledFunction) {
         CalledValue = CalledValue->stripPointerCasts();
         // Stripping pointer casts can reveal a called function.
         CalledFunction = dyn_cast<Function>(CalledValue);
       }
       // Check if this is an alias to a function. If so, get the
       // called aliasee for the checks below.
       if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
-        assert(!CalledFunction && "Expected null called function in callsite for alias");
         CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());
       }
       // Check if this is a direct call to a known function or a known
       // intrinsic, or an indirect call with profile data.
       if (CalledFunction) {
         if (CI && CalledFunction->isIntrinsic()) {
           addIntrinsicToSummary(
               CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,

llvm/test/Other/cgscc-refscc-mutation-order.ll

 ; RUN: opt -passes='cgscc(function(instcombine))' -debug-pass-manager -disable-output < %s 2>&1 | FileCheck %s
 
 ; We want to run passes on every SCC in a RefSCC without bailing even if one of the SCCs becomes a child SCC.
 
 ; This prevents explosive behavior on huge RefSCCs where a non-trivial amount of
 ; SCCs in the RefSCC become their own RefSCC as passes run on them. Otherwise we
 ; end up visiting the huge RefSCC the number of times that an SCC is split out
 ; rather than just twice.
 
 ; CHECK: Running pass: InstCombinePass on f1
-; CHECK-NOT: InstCombinePass
+; CHECK: InstCombinePass
 ; CHECK: Running pass: InstCombinePass on f2
-; CHECK-NOT: InstCombinePass
-; CHECK: Running pass: InstCombinePass on f3
-; CHECK-NOT: InstCombinePass
-; CHECK: Running pass: InstCombinePass on f4
-; CHECK-NOT: InstCombinePass
-; CHECK: Running pass: InstCombinePass on f1
+; CHECK: InstCombinePass
+; CHECK-NOT: Running pass: InstCombinePass on f3
+; CHECK: InstCombinePass
+; CHECK-NOT: Running pass: InstCombinePass on f4
+; CHECK: InstCombinePass
+; CHECK-NOT: Running pass: InstCombinePass on f1
 ; CHECK-NOT: InstCombinePass
 
 @a1 = alias void (), ptr @f1
 @a2 = alias void (), ptr @f2
 @a3 = alias void (), ptr @f3
 @a4 = alias void (), ptr @f4
 
 define void @f1() {

llvm/test/ThinLTO/X86/devirt_function_alias2.ll

 entry:
   %vtable2 = load ptr, ptr %obj2
   %p2 = call i1 @llvm.type.test(ptr %vtable2, metadata !"_ZTS1D")
   call void @llvm.assume(i1 %p2)
 
   %fptr33 = load ptr, ptr %vtable2, align 8
 
   ;; Check that the call was devirtualized.
-  ;; CHECK-IR1: %call4 = tail call i32 @_ZN1D1mEi
   %call4 = tail call i32 %fptr33(ptr nonnull %obj2, i32 %a)
   ret i32 %call4
 }
 ; CHECK-IR1-LABEL: ret i32
 ; CHECK-IR1-LABEL: }
 
 declare i1 @llvm.type.test(ptr, metadata)
 declare void @llvm.assume(i1)
 
 !3 = !{i64 16, !"_ZTS1D"}

llvm/test/Transforms/Inline/inline-alias.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function test --check-attributes --version 2
+; RUN: opt < %s -passes=inline -S | FileCheck %s
+
+@foo2 = alias i32 (), ptr @foo
+
+define i32 @foo() { ret i32 1 }
+; CHECK-LABEL: define i32 @foo() {
+; CHECK-NEXT:    ret i32 1
+;
+define i32 @test() {
+; CHECK-LABEL: define i32 @test() {
+; CHECK-NEXT:    ret i32 1
+;
+  %ret = call i32 @foo2()
+  ret i32 %ret
+}

llvm/test/Transforms/OpenMP/global_alias.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --function-signature --check-attributes
 ; RUN: opt -S -passes=openmp-opt < %s | FileCheck %s
 
 @alias = internal unnamed_addr alias void (ptr), ptr @callee
 
 define internal void @callee(ptr) {
+; CHECK: Function Attrs: nounwind memory(none)
 ; CHECK-LABEL: define {{[^@]+}}@callee
-; CHECK-SAME: (ptr [[TMP0:%.*]]) {
+; CHECK-SAME: (ptr [[TMP0:%.*]]) #[[ATTR0:[0-9]+]] {
 ; CHECK-NEXT:    ret void
 ;
   ret void
 }
 
 define void @caller(ptr %p) {
 ; CHECK-LABEL: define {{[^@]+}}@caller
 ; CHECK-SAME: (ptr [[P:%.*]]) {
-; CHECK-NEXT:    call void @alias(ptr [[P]])
 ; CHECK-NEXT:    ret void
 ;
   call void @alias(ptr %p)
   ret void
 }
 
 !llvm.module.flags = !{!0, !1}
 !0 = !{i32 7, !"openmp", i32 50}
 !1 = !{i32 7, !"openmp-device", i32 50}

llvm/test/Transforms/SampleProfile/indirect-call.ll

define void @foo_direct() #0 !dbg !21 {
   ret void
 }
 
 define i32 @foo_direct_i32() #0 !dbg !28 {
   ret i32 0;
 }
 
 ; CHECK-LABEL: @test_direct
-; We should not promote a direct call.
+; We should promote a direct call of alias.
 define void @test_direct() #0 !dbg !22 {
 ; CHECK-NOT: icmp
-; CHECK: call
+; CHECK-NOT: call
   call void @foo_alias(), !dbg !23
   ret void
 }
 
 @foo_alias = alias void (), ptr @foo_direct
 
 attributes #0 = {"use-sample-profile"}