[InlineASM][x86] Fix call external function in pic

[xiangzhangllvm]

Summary

This is a back end fix for https://reviews.llvm.org/D107523 [[Inline asm] Correct the constrain for function call in inline asm]
llvm-dev link: https://lists.llvm.org/pipermail/llvm-dev/2021-August/152144.html

The following code will generate one more time load for “sincos” with cmd “clang -fasm-blocks t.c -fpic -S -emit-llvm” + “llc t.ll”
t.c:

1 extern void sincos ();
2 void foo (){
3    __asm{
4    call  sincos
5    ret };
6 }

t.ll:

 1 define void @foo() #0 {
 2 entry:
 3   call void asm sideeffect inteldialect "call qword ptr ${0:P}\0A\09ret", "*m,~{dirflag},~{fpsr},~{flags}"(void (...)* @sincos) #2, !srcloc !5
4   ret void
5 }

t.s:

1         movq    sincos@GOTPCREL(%rip), %rax        // now the rax has been the function address  “sincos”
2 #APP
3       callq   *(%rax)                           //  the call should directly read the %rax, should not “load” it again, it should be “callq *%rax” or better code “call sincos@plt”
4        retq
5 #NO_APP

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

for (SDISelAsmOperandInfo &OpInfo : ConstraintOperands) {
 
     // Compute the constraint code and ConstraintType to use.
     TLI.ComputeConstraintToUse(OpInfo, OpInfo.CallOperand, &DAG);
 
     if (OpInfo.ConstraintType == TargetLowering::C_Memory &&
         OpInfo.Type == InlineAsm::isClobber)
       continue;
 
+    // TODO: Current arch of inline asm is not friendly to add special action
+    // for special instructions. So we add an unstandard/temp fix here, we
+    // need to refine it.
+    //
+    // Currently Clang will generate call func_name with "*m" constrain and
+    // "func_type * @func_name" in inlineasm.
+    // Not "m" + "func_type * @func_name" or "*m" + "func_type ** func".
+    // So backend we have 1 more time "load".
+    //
+    // For example: (clang -S -fasm-blocks -emit-llvm -fpic test.c)
+    // test.c:
+    // extern void func ();  void foo () {  __asm{ call sincos_asm; ret \n }; }
+    //
+    // will generate:
+    // IR:
+    // call void asm sideeffect inteldialect "call qword ptr ${0:P}",
+    // "*m,~{dirflag},~{fpsr},~{flags}"(void (...)* @func)
+    // asm:
+    // movq    func@GOTPCREL(%rip), %rax   \n      callq   *(%rax)
+    //
+    // we should directly "call *%rax" not "callq *(%rax)"
+    //
+    // So, here we manuly change the "*m" to "m".
+    if (OpInfo.CallOperand.getNode()
+        && TLI.isPositionIndependent()
+        && DAG.getSubtarget().getTargetTriple().isX86()
+        && OpInfo.CallOperand.getOpcode() == ISD::GlobalAddress
+        && OpInfo.CallOperandVal->getValueID() == Value::FunctionVal)
+      OpInfo.isIndirect = false;
+
     // If this is a memory input, and if the operand is not indirect, do what we
     // need to provide an address for the memory input.
     if (OpInfo.ConstraintType == TargetLowering::C_Memory &&
         !OpInfo.isIndirect) {
       assert((OpInfo.isMultipleAlternative ||
               (OpInfo.Type == InlineAsm::isInput)) &&
              "Can only indirectify direct input operands!");
 
void SelectionDAGBuilder::visitInlineAsm(const CallBase &Call,
 
   }
 
   // AsmNodeOperands - The operands for the ISD::INLINEASM node.
   std::vector<SDValue> AsmNodeOperands;
   AsmNodeOperands.push_back(SDValue());  // reserve space for input chain
   AsmNodeOperands.push_back(DAG.getTargetExternalSymbol(
       IA->getAsmString().c_str(), TLI.getProgramPointerTy(DAG.getDataLayout())));
 
   // If we have a !srcloc metadata node associated with it, we want to attach
   // this to the ultimately generated inline asm machineinstr.  To do this, we
   // pass in the third operand as this (potentially null) inline asm MDNode.
   const MDNode *SrcLoc = Call.getMetadata("srcloc");
   AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
 
   // Remember the HasSideEffect, AlignStack, AsmDialect, MayLoad and MayStore
   // bits as operand 3.

llvm/test/CodeGen/X86/semantic-interposition-asm.ll

 ; STATIC-NEXT:    movq fun0(%rip), %rax
 ; STATIC-NEXT:    movq (%rax), %rax
 ; STATIC-NEXT:    #NO_APP
 ; STATIC-NEXT:    retq
 ;
 ; CHECK-LABEL: test_fun:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    movq fun1@GOTPCREL(%rip), %rax
+; CHECK-NEXT:    movq %rax, -{{[0-9]+}}(%rsp)
 ; CHECK-NEXT:    #APP
 ; CHECK-NEXT:    movq .Lfun0$local(%rip), %rax
-; CHECK-NEXT:    movq (%rax), %rax
+; CHECK-NEXT:    movq -{{[0-9]+}}(%rsp), %rax
 ; CHECK-NEXT:    #NO_APP
 ; CHECK-NEXT:    retq
 entry:
   %0 = tail call i64 asm "movq $1, $0\0Amovq $2, $0", "=r,*m,*m"(void ()* nonnull @fun0, void ()* nonnull @fun1)
   ret i64 %0
 }