[SDAG] Don't pass inline asm blobs through ExternalSymbolSDNodes

[rnk]

Summary

Shoving the string through the ExternalSymbol uniquing hash tables is a
waste of time. Instead, just point at the InlineAsm value from the IR,
and pull the string out later when we lower to MI.

[rnk]

ping

lib/CodeGen/SelectionDAG/InstrEmitter.cpp

if (Node->getOperand(NumOps-1).getValueType() == MVT::Glue)
       --NumOps;  // Ignore the glue operand.
 
     // Create the inline asm machine instruction.
     MachineInstrBuilder MIB = BuildMI(*MF, Node->getDebugLoc(),
                                       TII->get(TargetOpcode::INLINEASM));
 
     // Add the asm string as an external symbol operand.
     SDValue AsmStrV = Node->getOperand(InlineAsm::Op_AsmString);
-    const char *AsmStr = cast<ExternalSymbolSDNode>(AsmStrV)->getSymbol();
-    MIB.addExternalSymbol(AsmStr);
+    const Value *SrcVal = cast<SrcValueSDNode>(AsmStrV)->getValue();
+    MIB.addExternalSymbol(cast<InlineAsm>(SrcVal)->getAsmString().c_str());
 
     // Add the HasSideEffect, isAlignStack, AsmDialect, MayLoad and MayStore
     // bits.
     int64_t ExtraInfo =
       cast<ConstantSDNode>(Node->getOperand(InlineAsm::Op_ExtraInfo))->
                           getZExtValue();
     MIB.addImm(ExtraInfo);
 

lib/CodeGen/SelectionDAG/ScheduleDAGSDNodes.h

static bool isPassiveNode(SDNode *Node) {
       if (isa<FrameIndexSDNode>(Node))     return true;
       if (isa<ConstantPoolSDNode>(Node))   return true;
       if (isa<TargetIndexSDNode>(Node))    return true;
       if (isa<JumpTableSDNode>(Node))      return true;
       if (isa<ExternalSymbolSDNode>(Node)) return true;
       if (isa<BlockAddressSDNode>(Node))   return true;
       if (Node->getOpcode() == ISD::EntryToken ||
           isa<MDNodeSDNode>(Node)) return true;
+      if (auto *SV = dyn_cast<SrcValueSDNode>(Node))
+        if (isa<InlineAsm>(SV->getValue()))
+          return true;
       return false;
     }
 
     /// NewSUnit - Creates a new SUnit and return a ptr to it.
     ///
     SUnit *newSUnit(SDNode *N);
 
     /// Clone - Creates a clone of the specified SUnit. It does not copy the

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

for (unsigned i = 0, e = ConstraintOperands.size(); i != e; ++i) {
     // to be.
     if (OpInfo.ConstraintType == TargetLowering::C_RegisterClass)
       GetRegistersForValue(DAG, TLI, getCurSDLoc(), OpInfo);
   }
 
   // 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.getPointerTy()));
+  AsmNodeOperands.push_back(DAG.getSrcValue(IA));
 
   // 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 = CS.getInstruction()->getMetadata("srcloc");
   AsmNodeOperands.push_back(DAG.getMDNode(SrcLoc));
 
   // Remember the HasSideEffect, AlignStack, AsmDialect, MayLoad and MayStore

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

SelectCodeCommon(SDNode *NodeToMatch, const unsigned char *MatcherTable,
   case ISD::AssertZext:
     CurDAG->ReplaceAllUsesOfValueWith(SDValue(NodeToMatch, 0),
                                       NodeToMatch->getOperand(0));
     return nullptr;
   case ISD::INLINEASM: return Select_INLINEASM(NodeToMatch);
   case ISD::READ_REGISTER: return Select_READ_REGISTER(NodeToMatch);
   case ISD::WRITE_REGISTER: return Select_WRITE_REGISTER(NodeToMatch);
   case ISD::UNDEF:     return Select_UNDEF(NodeToMatch);
+  case ISD::SRCVALUE:
+    // SrcValues wrapping inline asm are leaves and don't need selection.
+    if (isa<InlineAsm>(cast<SrcValueSDNode>(NodeToMatch)->getValue())) {
+      NodeToMatch->setNodeId(-1);
+      return nullptr;
+    }
+    break;
   }
 
   assert(!NodeToMatch->isMachineOpcode() && "Node already selected!");
 
   // Set up the node stack with NodeToMatch as the only node on the stack.
   SmallVector<SDValue, 8> NodeStack;
   SDValue N = SDValue(NodeToMatch, 0);
   NodeStack.push_back(N);