LLVM学习笔记（29）

最新推荐文章于 2024-03-21 18:05:48 发布
最新推荐文章于 2024-03-21 18:05:48 发布
阅读量801 收藏
点赞数
分类专栏： LLVM学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuhui_gdnt/article/details/79421496
版权

3.4.3.5. 辅助函数的生成

输出了MatcherTable后，EmitMatcherTable()在823行输出了一个汇总信息。对于3.6.1版本的X86，它是这样的（v7.0也是类似的）：

  // Opcode Histogram:

  // #OPC_Scope                          = 4240

  // #OPC_RecordNode                     = 2791

  // #OPC_RecordChild                    = 10029

  // #OPC_RecordMemRef                   = 2740

  // #OPC_CaptureGlueInput               = 14

  // #OPC_MoveChild                      = 8301

  // #OPC_MoveParent                     = 15070

  // #OPC_CheckSame                      = 0

  // #OPC_CheckChildSame                 = 809

  // #OPC_CheckPatternPredicate          = 11373

  // #OPC_CheckPredicate                 = 9754

  // #OPC_CheckOpcode                    = 7674

  // #OPC_SwitchOpcode                   = 612

  // #OPC_CheckType                      = 9002

  // #OPC_SwitchType                     = 2075

  // #OPC_CheckChildType                 = 1456

  // #OPC_CheckInteger                   = 4

  // #OPC_CheckChildInteger              = 1145

  // #OPC_CheckCondCode                  = 0

  // #OPC_CheckValueType                 = 36

  // #OPC_CheckComplexPat                = 7168

  // #OPC_CheckAndImm                    = 11

  // #OPC_CheckOrImm                     = 0

  // #OPC_CheckFoldableChainNode         = 2665

  // #OPC_EmitInteger                    = 260

  // #OPC_EmitStringInteger              = 869

  // #OPC_EmitRegister                   = 0

  // #OPC_EmitConvertToTarget            = 1922

  // #OPC_EmitMergeInputChains           = 7252

  // #OPC_EmitCopyToReg                  = 450

  // #OPC_EmitNode                       = 1043

  // #OPC_EmitNodeXForm                  = 71

  // #OPC_MarkGlueResults                = 0

  // #OPC_CompleteMatch                  = 163

  // #OPC_MorphNodeTo                    = 13006

在825~827行，完成了SelectCode()这个函数的定义。接下来，开始生成一系列的辅助方法。这些方法是指令选择器在解析MatcherTable进行指令选择时所必须的。这些信息都是在TD文件中给出的，描述了特定DAG结构匹配到特定机器指令所需要满足的条件或需要经历的操作。

615     void MatcherTableEmitter::EmitPredicateFunctions(formatted_raw_ostream &OS) {

616       // Emit pattern predicates.

617       if (!PatternPredicates.empty()) {

618         OS << "bool CheckPatternPredicate(unsigned PredNo) const override {\n";        <-- v7.0删除

    BeginEmitFunction(OS, "bool",                                                                                      <-- v7.0增加

          "CheckPatternPredicate(unsigned PredNo) const", true/*AddOverride*/);

    OS << "{\n";

619         OS << "  switch (PredNo) {\n";

620         OS << "  default: llvm_unreachable(\"Invalid predicate in table?\");\n";

621         for (unsigned i = 0, e = PatternPredicates.size(); i != e; ++i)

622           OS << "  case " << i << ": return "  << PatternPredicates[i] << ";\n";

623         OS << "  }\n";

624         OS << "}\n\n";

    EndEmitFunction(OS);                                                                                                      <-- v7.0增加

625       }

626    

627       // Emit Node predicates.

628       // FIXME: Annoyingly, these are stored by name, which we never even emit. Yay?    <-- v7.0删除

629       StringMap<TreePattern*> PFsByName;

630    

631       for (CodeGenDAGPatterns::pf_iterator I = CGP.pf_begin(), E = CGP.pf_end();

632            I != E; ++I)

633         PFsByName[I->first->getName()] = I->second.get();

634    

635       if (!NodePredicates.empty()) {

636         OS << "bool CheckNodePredicate(SDNode *Node,\n";                                              <-- v7.0删除

637         OS << "                        unsigned PredNo) const override {\n";

    BeginEmitFunction(OS, "bool",                                                                                       <-- v7.0增加

          "CheckNodePredicate(SDNode *Node, unsigned PredNo) const",

          true/*AddOverride*/);

    OS << "{\n";

638         OS << "  switch (PredNo) {\n";

639         OS << "  default: llvm_unreachable(\"Invalid predicate in table?\");\n";

640         for (unsigned i = 0, e = NodePredicates.size(); i != e; ++i) {

641           // Emit the predicate code corresponding to this pattern.

642           TreePredicateFn PredFn = NodePredicates[i];

643          

644           assert(!PredFn.isAlwaysTrue() && "No code in this predicate");

645           OS << "  case " << i << ": { // " << NodePredicates[i].getFnName() <<'\n';            <-- v7.0删除

646          

647         OS << PredFn.getCodeToRunOnSDNode() << "\n  }\n";

      OS << "  case " << i << ": { \n";                                                                                       <-- v7.0增加

      for (auto *SimilarPred :

           NodePredicatesByCodeToRun[PredFn.getCodeToRunOnSDNode()])

        OS << "    // " << TreePredicateFn(SimilarPred).getFnName() <<'\n';

 

      OS << PredFn.getCodeToRunOnSDNode() << "\n  }\n";

648         }

649         OS << "  }\n";

650         OS << "}\n\n";

    EndEmitFunction(OS);                                                                                                       <-- v7.0增加

651       }

652    

653       // Emit CompletePattern matchers.

654       // FIXME: This should be const.

655       if (!ComplexPatterns.empty()) {                                                                                       <-- v7.0删除

656         OS << "bool CheckComplexPattern(SDNode *Root, SDNode *Parent,\n";

657         OS << "                         SDValue N, unsigned PatternNo,\n";

658         OS << "         SmallVectorImpl<std::pair<SDValue, SDNode*> > &Result) override {\n";

    BeginEmitFunction(OS, "bool",                                                                                       ß v7.0增加

          "CheckComplexPattern(SDNode *Root, SDNode *Parent,\n"

          "      SDValue N, unsigned PatternNo,\n"

          "      SmallVectorImpl<std::pair<SDValue, SDNode*>> &Result)",

          true/*AddOverride*/);

659         OS << "  unsigned NextRes = Result.size();\n";

660         OS << "  switch (PatternNo) {\n";

661         OS << "  default: llvm_unreachable(\"Invalid pattern # in table?\");\n";

662         for (unsigned i = 0, e = ComplexPatterns.size(); i != e; ++i) {

663           const ComplexPattern &P = *ComplexPatterns[i];

664           unsigned NumOps = P.getNumOperands();

665    

666           if (P.hasProperty(SDNPHasChain))

667             ++NumOps;  // Get the chained node too.

668    

669           OS << "  case " << i << ":\n";

670           OS << "    Result.resize(NextRes+" << NumOps << ");\n";

671           OS << "    return "  << P.getSelectFunc();

672    

673           OS << "(";

674           // If the complex pattern wants the root of the match, pass it in as the

675           // first argument.

676           if (P.hasProperty(SDNPWantRoot))

677             OS << "Root, ";

678    

679           // If the complex pattern wants the parent of the operand being matched,

680           // pass it in as the next argument.

681           if (P.hasProperty(SDNPWantParent))

682             OS << "Parent, ";

683    

684           OS << "N";

685           for (unsigned i = 0; i != NumOps; ++i)

686             OS << ", Result[NextRes+" << i << "].first";

687           OS << ");\n";

      if (InstrumentCoverage) {                                                                                                <-- v7.0增加

        OS << "    if (Succeeded)\n";

        OS << "       dbgs() << \"\\nCOMPLEX_PATTERN: " << P.getSelectFunc()

           << "\\n\" ;\n";

        OS << "    return Succeeded;\n";

        OS << "    }\n";

688         }

689         OS << "  }\n";

690         OS << "}\n\n";

    EndEmitFunction(OS);                                                                                                         <-- v7.0增加

691       }

692    

693    

694       // Emit SDNodeXForm handlers.

695       // FIXME: This should be const.

696       if (!NodeXForms.empty()) {

697         OS << "SDValue RunSDNodeXForm(SDValue V, unsigned XFormNo) override {\n"; <-- v7.0删除

    BeginEmitFunction(OS, "SDValue",                                                                                    <-- v7.0增加

          "RunSDNodeXForm(SDValue V, unsigned XFormNo)", true/*AddOverride*/);

    OS << "{\n";

698         OS << "  switch (XFormNo) {\n";

699         OS << "  default: llvm_unreachable(\"Invalid xform # in table?\");\n";

700    

701         // FIXME: The node xform could take SDValue's instead of SDNode*'s.

702         for (unsigned i = 0, e = NodeXForms.size(); i != e; ++i) {

703           const CodeGenDAGPatterns::NodeXForm &Entry =

704             CGP.getSDNodeTransform(NodeXForms[i]);

705    

706           Record *SDNode = Entry.first;

707           const std::string &Code = Entry.second;

708    

709           OS << "  case " << i << ": {  ";

710           if (!OmitComments)

711             OS << "// " << NodeXForms[i]->getName();

712           OS << '\n';

713    

714           std::string ClassName = CGP.getSDNodeInfo(SDNode).getSDClassName();

715           if (ClassName == "SDNode")

716             OS << "    SDNode *N = V.getNode();\n";

717           else

718             OS << "    " << ClassName << " *N = cast<" << ClassName

719                << ">(V.getNode());\n";

720           OS << Code << "\n  }\n";

721         }

722         OS << "  }\n";

723         OS << "}\n\n";

    EndEmitFunction(OS);                                                                                                         <-- v7.0增加

724       }

725     }

一共有这几个地方会定义谓词。一个是Pattern定义里的Predicates，另一个就是Instruction定义里的Predicates。这些谓词分别保存在容器PatternPredicates与NodePredicates中。由于前者是字符串类型容器，因此对前者的处理相当简单，它生成如下函数：

bool CheckPatternPredicate(unsigned PredNo) const override {

  switch (PredNo) {

  default: llvm_unreachable("Invalid predicate in table?");

  case 0: return (Subtarget->hasAVX()) && (!Subtarget->hasVLX());

  case 1: return (Subtarget->hasSSE1() && !Subtarget->hasAVX());

  case 2: return (Subtarget->hasAVX512()) && (Subtarget->hasVLX());

  case 3: return (Subtarget->hasSSE2() && !Subtarget->hasAVX());

  case 4: return (Subtarget->hasSSE2());

  case 5: return (Subtarget->hasAVX2()) && (!Subtarget->hasVLX());

  case 6: return (Subtarget->hasAVX512());

  case 7: return (Subtarget->hasAVX());

  case 8: return (Subtarget->hasF16C());

  case 9: return (Subtarget->hasAVX() && !Subtarget->hasAVX512());

  case 10: return (Subtarget->hasSSE41() && !Subtarget->hasAVX());

  case 11: return (Subtarget->hasAVX512()) && (Subtarget->is64Bit());

  case 12: return (Subtarget->hasVLX());

  case 13: return (Subtarget->is64Bit());

  case 14: return (Subtarget->hasAVX() && !Subtarget->hasAVX2());

  case 15: return (Subtarget->hasAVX2());

  case 16: return (TM.getCodeModel() == CodeModel::Small ||TM.getCodeModel() == CodeModel::Kernel) && (TM.getRelocationModel() == Reloc::Static);

  case 17: return (Subtarget->hasMOVBE());

  case 18: return (Subtarget->hasBWI());

  case 19: return (Subtarget->hasDQI());

  case 20: return (Subtarget->hasAVX512()) && (!Subtarget->hasDQI());

  case 21: return (!Subtarget->hasSSE1());

  case 22: return (!Subtarget->hasSSE2());

  case 23: return (Subtarget->hasBWI()) && (Subtarget->hasVLX());

  case 24: return (Subtarget->hasMMX());

  case 25: return (Subtarget->hasLZCNT());

  case 26: return (Subtarget->hasBMI());

  case 27: return (Subtarget->hasCMov());

  case 28: return (!Subtarget->hasCMov());

  case 29: return (!Subtarget->hasSSE1()) && (Subtarget->hasCMov());

  case 30: return (!Subtarget->hasSSE2()) && (Subtarget->hasCMov());

  case 31: return (!Subtarget->slowIncDec());

  case 32: return (!Subtarget->hasSSE41());

  case 33: return (Subtarget->hasBMI2());

  case 34: return (Subtarget->hasTBM());

  case 35: return (!Subtarget->is64Bit());

  case 36: return (Subtarget->hasVLX()) && (Subtarget->hasBWI());

  case 37: return (!Subtarget->hasDQI());

  case 38: return (Subtarget->hasSSSE3());

  case 39: return (Subtarget->hasSSE42());

  case 40: return (Subtarget->hasSSE1());

  case 41: return (Subtarget->has3DNow());

  case 42: return (Subtarget->hasXOP());

  case 43: return (Subtarget->hasSHA());

  case 44: return (Subtarget->hasSSE42() && !Subtarget->hasAVX());

  case 45: return (Subtarget->hasSSSE3() && !Subtarget->hasAVX());

  case 46: return (Subtarget->hasAVX()) && (Subtarget->hasAES());

  case 47: return (Subtarget->hasAES());

  case 48: return (Subtarget->hasAVX()) && (Subtarget->hasPCLMUL());

  case 49: return (Subtarget->hasPCLMUL());

  case 50: return (Subtarget->hasSSE4A());

  case 51: return (Subtarget->hasSSE3() && !Subtarget->hasAVX());

  case 52: return (Subtarget->hasFMA4());

  case 53: return (Subtarget->hasPRFCHW());

  case 54: return (Subtarget->hasADX());

  case 55: return (Subtarget->hasDQI()) && (Subtarget->hasVLX());

  case 56: return (!Subtarget->is64Bit()) && (TM.getRelocationModel() != Reloc::PIC_);

  case 57: return (!Subtarget->isTarget64BitLP64());

  case 58: return (Subtarget->isTarget64BitLP64());

  case 59: return (Subtarget->hasSSE3());

  case 60: return (Subtarget->hasRTM());

  case 61: return (Subtarget->hasAVX()) && (!Subtarget->is64Bit());

  case 62: return (Subtarget->hasSSE2() && !Subtarget->hasAVX()) && (!Subtarget->is64Bit());

  case 63: return (Subtarget->hasAVX()) && (Subtarget->is64Bit());

  case 64: return (Subtarget->hasSSE2() && !Subtarget->hasAVX()) && (Subtarget->is64Bit());

  case 65: return (Subtarget->hasMMX()) && (!Subtarget->is64Bit());

  case 66: return (Subtarget->hasMMX()) && (Subtarget->is64Bit());

  case 67: return (Subtarget->hasFSGSBase()) && (Subtarget->is64Bit());

  case 68: return (!Subtarget->is64Bit()) && (!Subtarget->callRegIndirect());

  case 69: return (Subtarget->is64Bit()) && (!Subtarget->callRegIndirect());

  case 70: return (Subtarget->IsLegalToCallImmediateAddr(TM));

  case 71: return (Subtarget->hasPOPCNT());

  case 72: return (Subtarget->hasSSE2() && !Subtarget->hasAVX()) && (OptForSize);

  case 73: return (Subtarget->hasAVX() && !Subtarget->hasAVX512()) && (OptForSize);

  case 74: return (Subtarget->hasAVX512()) && (OptForSize);

  case 75: return (Subtarget->hasSSE2() && !Subtarget->hasAVX()) && (!OptForSize);

  case 76: return (Subtarget->hasAVX() && !Subtarget->hasAVX512()) && (!OptForSize);

  case 77: return (Subtarget->hasAVX512()) && (!OptForSize);

  case 78: return (Subtarget->hasVLX()) && (Subtarget->hasAVX512());

  case 79: return (Subtarget->hasAVX512()) && (!Subtarget->hasVLX());

  case 80: return (Subtarget->hasCmpxchg16b());

  case 81: return (TM.getCodeModel() != CodeModel::Small &&TM.getCodeModel() != CodeModel::Kernel);

  case 82: return (TM.getCodeModel() == CodeModel::Kernel);

  case 83: return (Subtarget->hasRDRAND());

  case 84: return (Subtarget->hasRDSEED());

  case 85: return (Subtarget->hasRTM() || Subtarget->hasHLE());

  case 86: return (!Subtarget->isTargetPS4());

  case 87: return (Subtarget->isTargetPS4());

  case 88: return (Subtarget->hasFMA());

  case 89: return (Subtarget->hasSSE1() && !Subtarget->hasAVX()) && (OptForSize);

  case 90: return (Subtarget->hasERI());

  case 91: return (Subtarget->hasSSE41());

  case 92: return (Subtarget->hasVLX()) && (Subtarget->hasDQI());

  }

}

至于NodePredicates，它是TreePredicateFn类型的容器，因此需要下面的方法来输出实质的代码。因为TreePredicateFn是TreePatternNode的一个成员，而TreePatternNode来自一个PatFrag定义。在PatFrag的定义里可以指定PredicateCode及ImmediateCode。ImmediateCode必须以int64_t类型的变量Imm为判断条件。而PredicateCode则要灵活一些，可以是任意类型的对象。

752     std::string TreePredicateFn::getCodeToRunOnSDNode() const {

753       // Handle immediate predicates first.

754       std::string ImmCode = getImmCode();

755       if (!ImmCode.empty()) {

756         std::string Result =

757          "    int64_t Imm = cast<ConstantSDNode>(Node)->getSExtValue();\n";

758         return Result + ImmCode;

759       }

760      

761       // Handle arbitrary node predicates.

762       assert(!getPredCode().empty() && "Don't have any predicate code!");

763       std::string ClassName;

764       if (PatFragRec->getOnlyTree()->isLeaf())

765         ClassName = "SDNode";

766       else {

767       Record *Op = PatFragRec->getOnlyTree()->getOperator();

768         ClassName = PatFragRec->getDAGPatterns().getSDNodeInfo(Op).getSDClassName();

769       }

770       std::string Result;

771       if (ClassName == "SDNode")

772         Result = "    SDNode *N = Node;\n";

773       else

774         Result = "    " + ClassName + "*N = cast<" + ClassName + ">(Node);\n";

775      

776       return Result + getPredCode();

777     }

这个生成的方法CheckNodePredicate()有接近1000行的代码，我们只看分别由ImmediateCode与PredicateCode生成的代码片段。

  case 85: { // Predicate_def32

    SDNode *N = Node;

  return N->getOpcode() != ISD::TRUNCATE &&

         N->getOpcode() != TargetOpcode::EXTRACT_SUBREG &&

         N->getOpcode() != ISD::CopyFromReg &&

         N->getOpcode() != ISD::AssertSext &&

         N->getOpcode() != X86ISD::CMOV;

  }

  case 86: { // Predicate_fpimm0

    ConstantFPSDNode*N = cast<ConstantFPSDNode>(Node);

  return N->isExactlyValue(+0.0);

  }

还有ComplexPattern的匹配方法要生成。前面在向MatcherTable输出CheckComplexPatMatcher对象时，getComplexPat()方法将ComplexPattern定义保存在ComplexPatterns容器里（EmitMatcher()的402行），同时对这些ComplexPattern进行了从0开始的编号。因此，X86会生成下面这个方法：

bool CheckComplexPattern(SDNode *Root, SDNode *Parent,

                         SDValue N, unsigned PatternNo,

         SmallVectorImpl<std::pair<SDValue, SDNode*> > &Result) override {

  unsigned NextRes = Result.size();

  switch (PatternNo) {

  default: llvm_unreachable("Invalid pattern # in table?");

  case 0:

    Result.resize(NextRes+5);

    return SelectAddr(Parent, N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 1:

    Result.resize(NextRes+6);

    return SelectScalarSSELoad(Root, N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first, Result[NextRes+5].first);

  case 2:

    Result.resize(NextRes+6);

    return SelectScalarSSELoad(Root, N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first, Result[NextRes+5].first);

  case 3:

    Result.resize(NextRes+5);

    return SelectLEAAddr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 4:

    Result.resize(NextRes+5);

    return SelectLEA64_32Addr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 5:

    Result.resize(NextRes+5);

    return SelectLEAAddr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 6:

    Result.resize(NextRes+1);

    return SelectMOV64Imm32(N, Result[NextRes+0].first);

  case 7:

    Result.resize(NextRes+5);

    return SelectTLSADDRAddr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 8:

    Result.resize(NextRes+5);

    return SelectTLSADDRAddr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 9:

    Result.resize(NextRes+5);

    return SelectTLSADDRAddr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 10:

    Result.resize(NextRes+5);

    return SelectTLSADDRAddr(N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  case 11:

    Result.resize(NextRes+5);

    return SelectVectorAddr(Parent, N, Result[NextRes+0].first, Result[NextRes+1].first, Result[NextRes+2].first, Result[NextRes+3].first, Result[NextRes+4].first);

  }

}

最后生成的是SDNodeXForm对象所要执行的转换操作。同样也是在向MatcherTable输出EmitNodeXFormMatcher对象时，getNodeXFormID()方法将SDNodeXForm对象保存到NodeXForms容器里，同时对这些SDNodeXForm进行了从0开始的编号。因此，X86会生成下面这个方法：

SDValue RunSDNodeXForm(SDValue V, unsigned XFormNo) override {

  switch (XFormNo) {

  default: llvm_unreachable("Invalid xform # in table?");

  case 0: {  // EXTRACT_get_vextract128_imm

    SDNode *N = V.getNode();

  return getI8Imm(X86::getExtractVEXTRACT128Immediate(N), SDLoc(N));

  }

  case 1: {  // GetLo8XForm

    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());

  // Transformation function: get the low 8 bits.

  return getI8Imm((uint8_t)N->getZExtValue(), SDLoc(N));

  }

  case 2: {  // GetLo32XForm

    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());

  // Transformation function: get the low 32 bits.

  return getI32Imm((unsigned)N->getZExtValue(), SDLoc(N));

  }

  case 3: {  // CountTrailingOnes

    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());

  // Count the trailing ones in the immediate.

  return getI8Imm(countTrailingOnes(N->getZExtValue()), SDLoc(N));

  }

  case 4: {  // ROT32L2R_imm8

    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());

  // Convert a ROTL shamt to a ROTR shamt on 32-bit integer.

  return getI8Imm(32 - N->getZExtValue(), SDLoc(N));

  }

  case 5: {  // ROT64L2R_imm8

    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());

  // Convert a ROTL shamt to a ROTR shamt on 64-bit integer.

  return getI8Imm(64 - N->getZExtValue(), SDLoc(N));

  }

  case 6: {  // INSERT_get_vinsert128_imm

    SDNode *N = V.getNode();

  return getI8Imm(X86::getInsertVINSERT128Immediate(N), SDLoc(N));

  }

  case 7: {  // INSERT_get_vinsert256_imm

    SDNode *N = V.getNode();

  return getI8Imm(X86::getInsertVINSERT256Immediate(N), SDLoc(N));

  }

  case 8: {  // I8Imm

    ConstantSDNode *N = cast<ConstantSDNode>(V.getNode());

  // Transformation function: get the low 8 bits.

  return getI8Imm((uint8_t)N->getZExtValue(), SDLoc(N));

  }

  case 9: {  // EXTRACT_get_vextract256_imm

    SDNode *N = V.getNode();

  return getI8Imm(X86::getExtractVEXTRACT256Immediate(N), SDLoc(N));

  }

  }

}

V7.0生成这样的版本：

#ifdef GET_DAGISEL_DECL

bool CheckPatternPredicate(unsigned PredNo) const override;

#endif

#if defined(GET_DAGISEL_BODY) || DAGISEL_INLINE

bool DAGISEL_CLASS_COLONCOLON CheckPatternPredicate(unsigned PredNo) const

#if DAGISEL_INLINE

  override

#endif

{

  switch (PredNo) {

      … 

  }

}

#endif // GET_DAGISEL_BODY

由于一些定义的变化以及处理上的改进，比如TreePattern共享相同的谓词，v7.0上述方法都有不小的变化。不过这里我们不深入其中的差异。

wuhui_gdnt
关注
专栏目录
LLVM笔记，自学系列，欢迎指教
09-20
LLVM笔记，自学系列，欢迎指教 LLVM（Low-Level Virtual Machine，低级虚拟机）是一款开源的编译器基础结构，提供了一个共同的...通过学习LLVM，可以更好地理解编译器的原理和实现，提高编程能力和编译器开发能力。
LLVM学习笔记（30）
wuhui_gdnt的专栏
03-16 2061
3.4.4.3. 生成代码如何辅助指令选择 3.4.4.3.1. 概述 我们首先以一个例子来说明这个过程是怎么开始的，这个例子来自Eli Bendersky的a deeper look into the llvm code generator part I： Eli Bendersky给出了这样一些简单的IR： define i64 @imul(i64 %a, i64 %b) nounwi...
llvm学习笔记（5）
wuhui_gdnt的专栏
03-24 3738
2.2.4. 匹配模板 在Instruction定义的333行，成员Pattern描述了该指令匹配怎么样的SelectionDAG结构。这是一个list类型，因此存在一条指令匹配多个dag结构的可能。在上面的例子中，这部分就是312~315行的dag。LLVM将对这样的dag生成movq2dq\t{$src, $dst|$dst, $src}形式的汇编代码（实际上，指令选择会生成一个Machin...
LLVM代码生成器进一步深入，第一部分
wuhui_gdnt的专栏
11-12 5655
原作：http://eli.thegreenplace.net/2013/02/25/a-deeper-look-into-the-llvm-code-generator-part-1/ 作者：Eli Bendersky 在前一篇文章中，我追踪了当从源语言编译到机器代码时，在LLVM中一条指令的各种化身。那篇文章简明地提到了LLVM中的许多层面，它们中的每一个都有趣且不简单。 这里我希望关注
llvm后端之SDNode设计
fs3296的博客
12-20 1479
DAG节点的类型(也就是操作类型，对应于指令类型)是定义在llvm::ISD::NodeType枚举类型中；EVT是对MVT的封装，此外还提供了对MVT类型的扩展。当表示MVT之外的类型时，其V.SimpleTy为INVALID_SIMPLE_VALUE_TYPE。蓝色表示指令序列化时两个节点中间可以插入其他节点对应的指令，而红色节点表示两个节点生成的指令中间不能插入其他节点的指令。llvm后端DAG的类型系统分为三个层级，从外到内为：EVT、MVT、SimpleValueType。
llvm后端
u012276729的博客
03-21 1221
SelectionDAGBuilder是LLVM（Low Level Virtual Machine）编译器中的一个重要组件，它负责将LLVM中间表示（Intermediate Representation，IR）转换为SelectionDAG（选择有向无环图）的形式。之前我们分析ir都是抽象出value和use，并且每一条ir都是从clang的ast遍历而来（use关系在ast中如何表示？
llvm_profile_materials
04-04
3. **583L3llvm.pdf**：这份文档的标题可能不明确，但基于上下文，它很可能是关于LLVM的课程材料或讲座笔记，其中可能涵盖了LLVM的内部工作原理，特别是关于其profile infrastructure的部分。可能会详细解释如何创建...
学习笔记内容包括但不限于C++ STL、编译原理、LLVM IR Pass代码优化、CSAPP Lab、uCore操作系统等等
最新发布
08-07
学习笔记&学习周报。内容包括但不限于C++ STL、编译原理、LLVM IR Pass代码优化、CSAPP Lab、uCore操作系统等等。.zip优质项目，资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到...
xamarin学习笔记B02(ios程序启动了解)
11-28
在本学习笔记B02中，我们将深入探讨Xamarin.iOS下的应用启动机制，主要包括以下关键知识点： 1. **Xamarin基础知识**：Xamarin是一种跨平台的移动开发框架，它允许开发者使用C#语言编写代码，生成原生的Android、...
LLVM学习笔记（15）
wuhui_gdnt的专栏
08-04 2145
3.4. DAG指令选择器的生成代码 3.4.1. 概述 选项-gen-dag-isel用于产生DAG指令选择器，处理这个选项的入口在EmitDAGISel()。TableGen首先根据对指令的描述，为指令定义中的匹配模板（亦称源模板，它指出长怎么样的IR代码片段能匹配这条指令）以及结果模板（它指出匹配成功后指令应该输出怎样的结果，这个结果包含隐含的寄存器的变化）构建DAG实例（下文的展开的T...
Value Use User
TomOfJerry的博客
02-25 496
LLVM中Value Use
LLVM指令选择过程理解
LF_AI的博客
12-30 1314
指令选择(instruction selection)是将中间语言转换成汇编或机器代码的过程。在LLVM后端中具体表现为模式匹配，目标指令选择阶段会把后端td文件里面的DAG模式和selection DAG的节点相匹配，如果找到一个匹配，则匹配的节点会被有具体机器指令（或者伪指令）的节点代替。1. LLVM IR基本概念LLVM IR是一门中间语言，向上承接C、JAVA等高级语言，向下可以被翻译成...
LLVM学习笔记（16）补
wuhui_gdnt的专栏
04-04 492
2.4.2.4.2.PatFrag的展开 在第一步完成后，我们为所有的PatFrag生成了TreePattern实例。接着，2490行的for循环对其中的片段进行展开。在第一次调用ParsePatternFragments()时（CodeGenDAGPatterns构造函数的2355行），展开输入模式。在第二次调用时（CodeGenDAGPatterns构造函数的2358行），展开输出模式（O...
LLVM学习笔记（6）
wuhui_gdnt的专栏
03-31 3987
2.2.4.2. 可复用的结构 2.2.4.2.1. PatFrag 高级语言的特征之一是支持数据与结构的复用，TD语言也吸取了这些长处，尝试为复杂而基本的操作提供复用的可能性。这就是PatFrag（SelectionTargetDAG.td）： 606     class PatFrag&lt;dag ops, dag frag, code pred = [{}], 607       ...
LLVM学习笔记（7）
wuhui_gdnt的专栏
04-07 2907
2.2.6. 调度信息 在Instruction定义430行的Itinerary以及433行的SchedRW用于描述指令调度的信息。 其中Itinerary是从指令执行步骤方面来描述指令。目标机器从InstrItinClass派生对应指令的定义。对像X86这样指令复杂且版本繁多的处理器来说，需要定义的InstrItinClass派生定义数量众多。它们都在X86Schedule.td里，几乎每条...
LLVM后端开发
Microwave
01-06 8806
LLVM后端 介绍这个文档描述了编写编译器后端的技术，将llvm IR转化为定制的机器代码或者其他语言。意图生成的特定机器码可以是汇编形式或者二进制形式（能够被JIT编译器使用）。LLVM的后端有一个目标无关为特征的代码生成器能够创建多种目标CPU类型的输出——包括X86，PowerPC，ARM和SPARC。后端也能够被用来生成特定的单元处理器或者GPU的SPU代码来支持内核计算的执行。这个文档关注
LLVM学习笔记（52）
wuhui_gdnt的专栏
12-27 1651
3.11.GlobalISel代码的自动生成（v7.0） 3.11.1.概述 GlobalISel是LLVM的一个新锐指令选择器。关于它的描述，首先是LLVM的在线文档： 第一部分参考v7.0的变化一节。 通用机器IR 机器IR工作在物理寄存器、寄存器类，以及（大部分情形）目标机器特定指令上。 为了填补LLVM IR的空缺，GlobalISel引入了机器I...
LLVM学习笔记（16）
wuhui_gdnt的专栏
08-18 2037
3.4.2.4. PatFrag的处理 3.4.2.4.1. 模式树的构建 PatFrag是一个可重用的构件，TableGen会在PatFrag出现的地方展开其定义，有点像C/C++中的宏。为此，CodeGenDAGPatterns将每个可能嵌入PatFrag的定义——Instruction，Pattern，Pat以及PatFrag，构建为一棵TreePattern树，并在适当的时候将其中包含...
RISC-V LLVM学习：vstart指令与Intrinsics函数详解
本文档是一份关于RISC-V-V架构下的LLVM（Low Level Virtual Machine）学习资料，由PLCT实验室实习生王鹏于2020年4月22日编写。主要探讨了以下几个关键主题： 1. **rvv-llvm中的新指令**：文档介绍了RISC-V-V规格...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值