dsa算法（9）

1.3.3.4.1.1.5. 对AtomicCmpXchg指令的处理

AtomicCmpXchg指令是原子性地从内存中载入一个值，与一个给定值比较，如果相等，向该处存入一个新值。同样，访问这个内存的必须是一个指针。在这个指令中，给定值与新值的类型必须

1.3.3.4.1.1.5. 对AtomicCmpXchg指令的处理

AtomicCmpXchg指令是原子性地从内存中载入一个值，与一个给定值比较，如果相等，向该处存入一个新值。同样，访问这个内存的必须是一个指针。在这个指令中，给定值与新值的类型必须相同，是宽度不小于8、不大于平台上限、为2的指数的整数，访问内存的指针必须指向这个类型。不管成功与否，AtomicCmpXchg指令都将返回指针所指向的值，因此AtomicCmpXchg指令的类型是由指针所指向值的类型决定。438~441行比较奇怪，参考visitAtomicRMWInst，似乎应该去掉。

 

437    voidGraphBuilder::visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) {

438      if (isa<PointerType>(I.getType())) {

439        visitInstruction (I);

440        return;

441      }

442   

443      //

444      // Create a DSNodefor the dereferenced pointer .  If theDSNode is NULL, do

445      // nothing more(this can occur if the pointer is a NULL constant; bugpoint

446      // can generatesuch code).

447      //

448      DSNodeHandle Ptr = getValueDest(I.getPointerOperand());

449      if (Ptr.isNull()) return;

450   

451      //

452      // Make that thememory object is read and written.

453      //

454      Ptr.getNode()->setReadMarker();

455      Ptr.getNode()->setModifiedMarker();

456   

457      //

458      // If the result ofthe compare-and-swap is a pointer, then we need to do

459      // a few things:

460      //  o Merge the compare and swap values (whichare pointers) with the result

461      //  o Merge the DSNode of the pointer *within*the memory object with the

462      //    DSNode of the compare, swap, and resultDSNode.

463      //

464      if (isa<PointerType>(I.getType())) {

465        //

466        // Get the DSNodeHandle of the memory objectreturned from the load.  Make

467        // it the DSNodeHandle of the instruction'sresult.

468        //

469        DSNodeHandle FieldPtr = getLink (Ptr);

470        setDestTo(I,getLink(Ptr));

471   

472        //

473        // Merge the result, compare, and swap valuesof the instruction.

474        //

475        FieldPtr.mergeWith(getValueDest (I.getCompareOperand()));

476        FieldPtr.mergeWith (getValueDest(I.getNewValOperand()));

477      }

478   

479      //

480      // Modify theDSNode so that it has the loaded/written type at the

481      // appropriateoffset.

482      //

483     Ptr.getNode()->growSizeForType(I.getType(), Ptr.getOffset());

484      Ptr.getNode()->mergeTypeInfo(I.getType(), Ptr.getOffset());

485      return;

486    }

 

如果指针所指向的值本身也是一个指针类型，该值与给定值及新值构成别名，因此需要把它们指向的对象的DSNode节点进行简并（475~476行）。

1.3.3.4.1.1.6. 对AtomicRMW指令的处理

AtomicRMW指令是原子性地从内存中载入一个值，修改，然后回写。指令返回内存的初值。修改操作由指令的参数指定。

 

488    void GraphBuilder::visitAtomicRMWInst(AtomicRMWInst&I) {

489      //

490      // Create a DSNodefor the dereferenced pointer .  If theDSNode is NULL, do

491      // nothing more(this can occur if the pointer is a NULL constant; bugpoint

492      // can generatesuch code).

493      //

494      DSNodeHandle Ptr = getValueDest(I.getPointerOperand());

495      if (Ptr.isNull()) return;

496   

497      //

498      // Make that thememory object is read and written.

499      //

500      Ptr.getNode()->setReadMarker();

501      Ptr.getNode()->setModifiedMarker();

502   

503      //

504      // Modify theDSNode so that it has the loaded/written type at the

505      // appropriateoffset.

506      //

507     Ptr.getNode()->growSizeForType(I.getType(), Ptr.getOffset());

508      Ptr.getNode()->mergeTypeInfo(I.getType(), Ptr.getOffset());

509      return;

510    }

 

同样，必须通过一个指针访问这个内存。指针指向对象的类型与指令本身的类型是一致的，但这个内存有可能是结构体的一部分，508行让这个结构体知道这个情况。

1.3.3.4.1.1.7. 对Return指令的处理

这是函数返回值的抽象。514行的FB是这个GraphBuilder所对应的Function实例，如果返回值是一个指针类型，把返回值节点与函数中代表返回语句的节点进行简并。

 

512    void GraphBuilder::visitReturnInst(ReturnInst&RI) {

513      if (RI.getNumOperands() &&isa<PointerType>(RI.getOperand(0)->getType()))

514        G.getOrCreateReturnNodeFor(*FB).mergeWith(getValueDest(RI.getOperand(0)));

515    }

 

DSGraph中的成员ReturnNodes（类型std::map<constFunction*, DSNodeHandle>）专门用于保存函数的返回值，上面的getOrCreateReturnNodeFor就是为该函数在ReturnNodes中返回对应的DSNodeHandle，如果不存在就新创建（不过，函数的GraphBuilder在构造函数中已经创建了ReturnNodes）。

显然，如果函数没有返回值（void），ReturnNodes将是空的。

1.3.3.4.1.1.8. 对变长参数的处理

CallSite在llvm中代表调用点。这里是对va_start的调用（va_start是llvm的内置函数，而不是定义为宏，参考clang，va_start被定义为__builtin_va_start）。va_start的一般调用形式为：va_start (ap, param)。

 

912    void GraphBuilder::visitVAStart(CallSite CS) {

913      // Build outDSNodes for the va_list depending on the target arch

914      // And assosiatethe right node with the VANode for this function

915      // so it can bemerged with the right arguments from callsites

916   

917      DSNodeHandle RetNH = getValueDest(CS.getArgument(0));

918   

919      if (DSNode *N = RetNH.getNode())

920        visitVAStartNode(N);

921    }

 

Va_start的第一个参数具有va_list*类型，va_start使得这个参数指向实参列表。上面为ap的实参创建在DSGraph中的代表——DSNode及DSNodeHandle。

在DSGraph中VANodes域专门为每个函数提供变长参数的绑定。VANodes的类型是std::map<const Function*, DSNodeHandle>，getVANodeFor返回在其中与指定Function*关联的DSNodeHandle。

VAArray则是GraphBuilder的成员，初始化为0。每个函数都有自己的GraphBuilder，因此VAArray实例是与函数对应的。它代表可变实参列表。在941行，va_start的ap实参指向了实参列表（VANH是DSNodeHandle，VAArray是DSNode，在DSA算法中DSNodeHandle视为指向DSNode的指针）。

 

922    void GraphBuilder::visitVAStartNode(DSNode*N) {

923      assert(N&& "Null node as argument");

924      assert(FB&& "No function for this graph?");

925      Module *M = FB->getParent();

926      assert(M&& "No module for function");

927      Triple TargetTriple(M->getTargetTriple());

928      Triple::ArchType Arch =TargetTriple.getArch();

929   

930      // Fetch theVANode associated with the func containing the call to va_start

931      DSNodeHandle & VANH =G.getVANodeFor(*FB);

932      // Make sure thisNodeHandle has a node to go with it

933      if (VANH.isNull()) VANH.mergeWith(createNode());

934   

935      // Create adsnode for an array of pointers to the VAInfo for this func

936      // We create onesuch array for each function analyzed, as all

937      // calls tova_start will populate their argument with the same data.

938      if (!VAArray) VAArray = createNode();

939      VAArray->setArrayMarker();

940      VAArray->foldNodeCompletely();

941      VAArray->setLink(0,VANH);

942   

943      //VAStartmodifies its argument

944     N->setModifiedMarker();

945   

946      // For thearchitectures we support, build dsnodes that match

947      // how we knowva_list is used.

948      switch (Arch){

949      caseTriple::x86:

950        // On x86, wehave:

951        // va_list as apointer to an array of pointers to the variable arguments

952        if (N->getSize() < 1)

953          N->growSize(1);

954        N->setLink(0, VAArray);

955        break;

956      caseTriple::x86_64:

957        // On x86_64,we have va_list as a struct {i32, i32, i8*, i8* }

958        // The firsti8* is where arguments generally go, but the second i8* can

959        // be used alsoto pass arguments by register.

960        // We modelthis by having both the i8*'s point to an array of pointers

961        // to thearguments.

962        if (N->getSize() < 24)

963          N->growSize(24); //sizeof the va_list struct mentioned above

964        N->setLink(8,VAArray); //first i8*

965        N->setLink(16,VAArray); //second i8*

966   

967        break;

968      default:

969        // FIXME: Fornow we abort if we don't know how to handle this arch

970        // Either addsupport for other architectures, or at least mark the

971        // nodesunknown/incomplete or whichever results in the correct

972        // conservativebehavior in the general case

973        assert(0&& "VAstart not supported on this architecture!");

974        //XXX: Thismight be good enough in those cases that we don't know

975        //what the archdoes

976       N->setIncompleteMarker()->setUnknownMarker()->foldNodeCompletely();

977      }

978   

979      // XXX: We usedto set the alloca marker for the DSNode passed to va_start.

980      // Seems to methat you could allocate the va_list on the heap, so ignoring

981      // for now.

982     N->setModifiedMarker()->setVAStartMarker();

983    }

 

接下来，让ap的实参指向这个实参列表，在这一块DSA目前只支持x86系列机器。对于32位的x86机器，va_list类型是指向变长实参指针数组的指针，而对于64位x86机器，va_list的类型则是{i32, i32, i8*, i8*}。这里的N代表ap的实参，因此952~955，962~965行都是在DSGraph中表示ap实参指向实参列表。

在使用va_start将ap与实参列表绑定后，通过va_arg指令获取下一个指定类型的实参的地址。va_arg指令的语法是：x = va_arg(ap, type)。

 

517    void GraphBuilder::visitVAArgInst(VAArgInst&I) {

518      Module *M = FB->getParent();

519      Triple TargetTriple(M->getTargetTriple());

520      Triple::ArchType Arch =TargetTriple.getArch();

521      switch(Arch){

522      caseTriple::x86_64: {

523        // On x86_64, wehave va_list as a struct {i32, i32, i8*, i8* }

524        // The first i8* is where argumentsgenerally go, but the second i8* can

525        // be used alsoto pass arguments by register.

526        // We modelthis by having both the i8*'s point to an array of pointers

527        // to thearguments.

528        DSNodeHandle Ptr = G.getVANodeFor(*FB);

529        DSNodeHandle Dest = getValueDest(&I);

530        if (Ptr.isNull()) return;

531   

532        // Make thatthe node is read and written

533       Ptr.getNode()->setReadMarker()->setModifiedMarker();

534   

535        // Not updatingtype info, as it is already a collapsed node

536   

537        if (isa<PointerType>(I.getType()))

538          Dest.mergeWith(Ptr);

539        return;

540      }

541   

542      default: {

543        assert(0&& "What frontend generates this?");

544        DSNodeHandle Ptr = getValueDest(I.getOperand(0));

545   

546        //FIXME: alsoupdates the argument

547        if (Ptr.isNull()) return;

548   

549        // Make thatthe node is read and written

550       Ptr.getNode()->setReadMarker()->setModifiedMarker();

551   

552        // Ensure atype record exists.

553        DSNode *PtrN = Ptr.getNode();

554        PtrN->mergeTypeInfo(I.getType(),Ptr.getOffset());

555   

556        if (isa<PointerType>(I.getType()))

557          setDestTo(I,getLink(Ptr));

558      }

559      }

560    }

 

因为前面看到，对于32位x86机器，va_list是指向变长实参指针数组的指针，而且这个数组实际上已经缩合了（visitVAStartNode的940行），因此，在这里不需要进一步的处理。对于64位x86机器，528行的Ptr是前面va_start的ap实参，它已经指向实参列表。在537行，va_arg的类型就是返回的实参的类型，如果该类型是指针，那么它也指向实参列表，这反映在538行与Ptr进行的简并。

而va_end，va_copy则在visitIntrinsic中处理。

1.3.3.4.1.1.9. 对intrinsic指令的处理

Llvm支持intrinsic函数的概念。这些函数都有广为人知的名字及语义，并要求遵循一定的约束。总之，这些intrinsic函数代表了llvm语言的一个扩展机制，在添加入语言（或字节码读写器，解析器等等）时，不需要改变llvm中所有的转换（transformation）。

Llvm定义了如下的intrinsic函数（详情参考llvm语言在线手册）：

Llvm.va_start，它的作用与C宏va_start相同。

Llvm.va_end，它的作用与C宏va_end相同，销毁va_start初始化的va_list。

Llvm.va_copy，它的作用与C宏va_copy相同，将源va_list拷贝到目标va_list。

Llvm.returnaddress，它返回表示指定调用框的返回地址的指针，在不能识别时，返回0。这仅用于调试。

Llvm.frameaddress，它返回表示指定调用框的框地址的指针，在不能识别时，返回0。这仅用于调试。

Llvm.stacksave，它返回一个可以传递给llvm.restore的不透明度的指针。当llvm.stackrestore以llvm.stacksave保存的值执行时，它实际上把栈恢复到执行llvm.stacksave时的状态。

Llvm.prefetch，它暗示代码生成器，如果支持，插入一个预取指令。

Llvm.lifetime.start，它表示在代码中该点之前，指定内存的值是无用的。这意味着已知该内存不会被用到且有未定义的值。

Llvm.lifetime.end，它表示在代码中该点之后，指定内存的值是无用的。这意味着已知该内存不会被用到且有未定义的值。

Llvm.invariant.start，它表示直到使用其返回值的llvm.invariant.end，期间所引用的内存位置是不变的。

Llvm.eh.typeid.for，它返回在当前函数异常表中的type info索引。

 

1000  bool GraphBuilder::visitIntrinsic(CallSiteCS, Function *F) {

1001    ++NumIntrinsicCall;

1002 

1003    //

1004    // If this is adebug intrinsic, then don't do any special processing.

1005    //

1006    if(isa<DbgInfoIntrinsic>(CS.getInstruction()))

1007      returntrue;

1008 

1009    switch(F->getIntrinsicID()) {

1010    caseIntrinsic::vastart: {

1011      visitVAStart(CS);

1012      returntrue;

1013    }

1014    caseIntrinsic::vacopy: {

1015      // Simply mergethe two arguments to va_copy.

1016      // This resultsin loss of precision on the temporaries used to manipulate

1017      // the va_list,and so isn't a big deal.  In theory wewould build a

1018      // separategraph for this (like the one created in visitVAStartNode)

1019      // and onlymerge the node containing the variable arguments themselves.

1020      DSNodeHandle destNH =getValueDest(CS.getArgument(0));

1021      DSNodeHandle srcNH = getValueDest(CS.getArgument(1));

1022      destNH.mergeWith(srcNH);

1023      returntrue;

1024    }

1025    caseIntrinsic::stacksave: {

1026      DSNode * Node = createNode();

1027     Node->setAllocaMarker()->setIncompleteMarker()->setUnknownMarker();

1028      Node->foldNodeCompletely();

1029      setDestTo(*(CS.getInstruction()), Node);

1030      returntrue;

1031    }

1032    caseIntrinsic::stackrestore:

1033      getValueDest(CS.getInstruction()).getNode()->setAllocaMarker()

1034        ->setIncompleteMarker()

1035        ->setUnknownMarker()

1036        ->foldNodeCompletely();

1037      returntrue;

1038    caseIntrinsic::vaend:

1039      // TODO: Whatto do here?

1040      returntrue;

1041    caseIntrinsic::memcpy:

1042    caseIntrinsic::memmove: {

1043      // Merge thefirst & second arguments, and mark the memory read and

1044      // modified.

1045      DSNodeHandle RetNH = getValueDest(CS.getArgument(0));

1046      RetNH.mergeWith(getValueDest(CS.getArgument(1)));

1047      if (DSNode *N = RetNH.getNode())

1048       N->setModifiedMarker()->setReadMarker();

1049      returntrue;

1050    }

1051    caseIntrinsic::memset:

1052      // Mark thememory modified.

1053      if (DSNode *N = getValueDest(CS.getArgument(0)).getNode())

1054        N->setModifiedMarker();

1055      returntrue;

1056 

1057      // TODO: Addsupport for the new EH system

1058  #if 0

1059    case Intrinsic::eh_exception: {

1060      DSNode * Node = createNode();

1061      Node->setIncompleteMarker();

1062      Node->foldNodeCompletely();

1063      setDestTo (*(CS.getInstruction()), Node);

1064      return true;

1065    }

1066 

1067    case Intrinsic::eh_selector: {

1068      for (CallSite::arg_iterator I =CS.arg_begin(), E = CS.arg_end();

1069           I != E; ++I) {

1070        if(isa<PointerType>((*I)->getType())) {

1071          DSNodeHandle Ptr = getValueDest(*I);

1072          if(Ptr.getNode()) {

1073            Ptr.getNode()->setReadMarker();

1074           Ptr.getNode()->setIncompleteMarker();

1075          }

1076        }

1077      }

1078      return true;

1079    }

1080  #endif

1081 

1082    caseIntrinsic::eh_typeid_for: {

1083      DSNodeHandle Ptr = getValueDest(CS.getArgument(0));

1084      Ptr.getNode()->setReadMarker();

1085      Ptr.getNode()->setIncompleteMarker();

1086      returntrue;

1087    }

1088 

1089    caseIntrinsic::prefetch:

1090      returntrue;

1091 

1092    caseIntrinsic::objectsize:

1093      returntrue;

1094 

1095      //

1096      // The returnaddress/frame address aliases with the stack,

1097      // istype-unknown, and should

1098      // have theunknown flag set since we don't know where it goes.

1099      //

1100    caseIntrinsic::returnaddress:

1101    caseIntrinsic::frameaddress: {

1102      DSNode * Node = createNode();

1103     Node->setAllocaMarker()->setIncompleteMarker()->setUnknownMarker();

1104     Node->foldNodeCompletely();

1105      setDestTo(*(CS.getInstruction()), Node);

1106      returntrue;

1107    }

1108 

1109    // Process lifetime intrinsics

1110    caseIntrinsic::lifetime_start:

1111    caseIntrinsic::lifetime_end:

1112    caseIntrinsic::invariant_start:

1113    caseIntrinsic::invariant_end:

1114      returntrue;

1115 

1116    default: {

1117      //ignorepointer free intrinsics

1118      if (!isa<PointerType>(F->getReturnType())){

1119        bool hasPtr = false;

1120        for(Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();

1121             I != E && !hasPtr; ++I)

1122          if(isa<PointerType>(I->getType()))

1123            hasPtr = true;

1124        if (!hasPtr)

1125          returntrue;

1126      }

1127 

1128      DEBUG(errs() << "[dsa:local]Unhandled intrinsic: " << F->getName() << "\n");

1129      assert(0&& "Unhandled intrinsic");

1130      returnfalse;

1131    }

1132    }

1133  }

 

注意1033行，llvm.stackrestore被视为通过alloca从栈上分配。

1.3.3.4.1.1.10. 对整数ßà指针指令的处理

IntToPtrInst代表把一个整数转换到一个指针。由于Value是IntToPtrInst的基类之一，如果这个Value只有一个用户（llvm的User类），hasOneUse返回true。如果该用户是ICmpInst——整数/指针比较语句，那么566行的NumBoringIntToPtr用于统计这种事件。在其他情况，由于得到的指针所指向的内存对象未知，在571行进行标记。

 

562    void GraphBuilder::visitIntToPtrInst(IntToPtrInst&I) {

563      DSNode *N = createNode();

564      if(I.hasOneUse()) {

565        if(isa<ICmpInst>(*(I.use_begin()))) {

566          NumBoringIntToPtr++;

567          return;

568        }

569      } else {

570        N->setIntToPtrMarker();

571        N->setUnknownMarker();

572      }

573      setDestTo(I,N);

574    }

 

类似的，PtrToIntInst代表把一个指针转换到一个整数。586行的DenseSet是llvm定义的容器，其在588行的insert方法返回std::pair<iterator, bool>，在插入成功或对象已在容器中时，返回pair的第二个元素是true。那么587行while循环的作用就是沿着用户链，发掘类型为BranchInst的用户，进行统计。NumBoringIntToPtr统记了仅用在cmp的inttoptr的数目。

 

576    void GraphBuilder::visitPtrToIntInst(PtrToIntInst&I) {

577      DSNode* N = getValueDest(I.getOperand(0)).getNode();

578      if(I.hasOneUse()) {

579        if(isa<ICmpInst>(*(I.use_begin()))) {

580          NumBoringIntToPtr++;

581          return;

582        }

583      }

584      if(I.hasOneUse()) {

585        Value *V = dyn_cast<Value>(*(I.use_begin()));

586        DenseSet<Value *> Seen;

587        while(V&& V->hasOneUse() &&

588              Seen.insert(V).second) {

589          if(isa<LoadInst>(V))

590            break;

591          if(isa<StoreInst>(V))

592            break;

593          if(isa<CallInst>(V))

594            break;

595          V =dyn_cast<Value>(*(V->use_begin()));

596        }

597        if(isa<BranchInst>(V)){

598          NumBoringIntToPtr++;

599          return;

600        }

601      }

602      if(N)

603        N->setPtrToIntMarker();

604    }

1.3.3.4.1.1.11. 对bitcast指令的处理

BitCastInst代表一个空操作转换，因为这个转换没有比特位的改变。显然对于DSA，这个转换在涉及指针时才有价值。

 

607    void GraphBuilder::visitBitCastInst(BitCastInst&I) {

608      if (!isa<PointerType>(I.getType())) return; // Only pointers

609      DSNodeHandle Ptr = getValueDest(I.getOperand(0));

610      if (Ptr.isNull()) return;

611      setDestTo(I,Ptr);

612    }

1.3.3.4.1.1.12. 对insertvalue指令的处理

InsertValueInst向一个聚集类型（struct/class/union或数组）值的一个数据成员插入值，并返回更新后的聚集类型值。InsertValueInst带至少三个参数，第一个是聚集类型值，第二个是插入的值，第三个是指示插入位置的常量。

 

648    void GraphBuilder::visitInsertValueInst(InsertValueInst&I) {

649      setDestTo(I,createNode()->setAllocaMarker());

650   

651      Type *StoredTy =I.getInsertedValueOperand()->getType();

652      DSNodeHandle Dest = getValueDest(&I);

653      Dest.mergeWith(getValueDest(I.getAggregateOperand()));

654   

655      // Mark that thenode is written to...

656      Dest.getNode()->setModifiedMarker();

657      Type* STy =I.getAggregateOperand()->getType();

658   

659      unsigned Offset = getValueOffset(STy,I.getIndices(), TD);

660   

661      // Ensure atype-record exists...

662      Dest.getNode()->mergeTypeInfo(StoredTy, Offset);

663   

664      // Avoid addingedges from null, or processing non-"pointer" stores

665      if (isa<PointerType>(StoredTy))

666        Dest.addEdgeTo(getValueDest(I.getInsertedValueOperand()));

667    }

 

在649行，为InsertValueInst创建了DSNodeHandle，并指向同一行构建的标记为alloca的DSNode（代表其在栈上构建的返回值）。这个DSNodeHandle在652行通过getValueDesc给出。接着在653行，它与第一个参数的节点发生了简并（因为它们的指针域都要指向相同的地方）。因为llvm IR要求操作数的类型必须严格匹配，因此662行确保要保存的值的类型存在于结构体指定的位置上（至于这个位置所代表的多个类型是否相容就是另一个问题了）。最后，如果插入的值是个指针，在666行让Dest有指向该指针指向对象的一条边。

1.3.3.4.1.1.13. 对extractvalue指令的处理

ExtractValueInst则是InsertValueInst的相反操作——从一个聚集类型值的指定域提取值。它也类似地带至少三个参数，第一个是聚集类型值，第二个是提取的值，第三个是指示提取位置的常量。

 

669    void GraphBuilder::visitExtractValueInst(ExtractValueInst&I) {

670      DSNodeHandle Ptr = getValueDest(I.getAggregateOperand());

671   

672      // Make that thenode is read from...

673      Ptr.getNode()->setReadMarker();

674      Type* STy =I.getAggregateOperand()->getType();

675   

676      unsigned Offset = getValueOffset(STy,I.getIndices(), TD);

677   

678      // Ensure atyperecord exists...

679      Ptr.getNode()->mergeTypeInfo(I.getType(), Offset);

680   

681      if (isa<PointerType>(I.getType()))

682        setDestTo(I,getLink(Ptr));

683    }

 

这里的处理与InsertValueInst类似，且更简单。

1.3.3.4.1.1.14. 对GetElementPtr指令的处理

参考1.3.3.2.2.2. 对GetElementPtr指令的处理一节。

1.3.3.4.1.1.15. 对调用指令的处理

在llvm IR中，CallInst来自call指令，InvokeInst来自invoke指令。两者都是对函数的调用，主要的区别在于，invoke指令会创建与一个标记的关联，该关联被运行时用于回滚栈。不过，对于DSA这两者没有区别。

 

904    void GraphBuilder::visitCallInst(CallInst&CI) {

904      visitCallSite(&CI);

904    }

 

904    void GraphBuilder::visitInvokeInst(InvokeInst&II) {

904      visitCallSite(&II);

904    }

 

要以相同的方式处理CallInst及InvokeInst，就要用到CallSite。它是llvm专门提供的一个便利的封装类。Intrinsic函数由1143行的visitIntrinsic处理。而对于内联汇编函数，采用保守的处理，把所有的指针视为互为别名，进行简并，并缩合返回值节点，如果它是指针。

 

1135  void GraphBuilder::visitCallSite(CallSite CS){

1136    //

1137    // Get the calledvalue.  Strip off any casts which arelossless.

1138    //

1139    Value *Callee =CS.getCalledValue()->stripPointerCasts();

1140 

1141    // Special case handlingof certain libc allocation functions here.

1142    if (Function *F =dyn_cast<Function>(Callee))

1143      if (F->isIntrinsic() && visitIntrinsic(CS, F))

1144        return;

1145 

1146    //Can't do muchabout inline asm (yet!)

1147    if (isa<InlineAsm> (Callee)) {

1148      ++NumAsmCall;

1149      DSNodeHandle RetVal;

1150      Instruction *I = CS.getInstruction();

1151      if (isa<PointerType >(I->getType()))

1152        RetVal = getValueDest(I);

1153 

1154      // Calculatethe arguments vector...

1155      for(CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); I != E; ++I)

1156        if (isa<PointerType >((*I)->getType()))

1157          RetVal.mergeWith(getValueDest(*I));

1158      if (!RetVal.isNull())

1159        RetVal.getNode()->foldNodeCompletely();

1160      return;

1161    }

1162 

1163    // Set up thereturn value...

1164    DSNodeHandle RetVal;

1165    Instruction *I = CS.getInstruction();

1166    if (isa<PointerType>(I->getType()))

1167      RetVal = getValueDest(I);

1168 

1169    DSNode *CalleeNode = 0;

1170    if (!isa<Function>(Callee)) {

1171      CalleeNode = getValueDest(Callee).getNode();

1172      if (CalleeNode == 0) {

1173        DEBUG(errs() << "WARNING:Program is calling through a null pointer?\n" << *I);

1174        return;  // Calling a nullpointer?

1175      }

1176    }

1177 

1178    // NOTE: Thiscode is identical to 'DSGraph::getDSCallSiteForCallSite',

1179    // the reasonit's duplicated is because this calls getValueDest instead

1180    // ofgetNodeForValue to get the DSNodes for the arguments.  Since we're in

1181    // local it'spossible that we need to create a DSNode for the argument, as

1182    // opposed togetNodeForValue which simply retrieves the existing node.

1183 

1184 

1185    //Get theFunctionType for the called function

1186    constFunctionType *CalleeFuncType = DSCallSite::FunctionTypeOfCallSite(CS);

1187    int NumFixedArgs =CalleeFuncType->getNumParams();

1188 

1189    // Sanitycheck--this really, really shouldn't happen

1190    if (!CalleeFuncType->isVarArg())

1191      assert(CS.arg_size()== static_cast<unsigned>(NumFixedArgs)&&

1192             "Too many arguments/incorrectfunction signature!");

1193 

1194    std::vector<DSNodeHandle> Args;

1195    Args.reserve(CS.arg_size());

1196    DSNodeHandle VarArgNH;

1197 

1198    // Calculate thearguments vector...

1199    // Add all fixedpointer arguments, then merge the rest together

1200    for(CallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();

1201         I != E; ++I)

1202      if(isa<PointerType>((*I)->getType())) {

1203        DSNodeHandle ArgNode = getValueDest(*I);

1204        if (I - CS.arg_begin() < NumFixedArgs){

1205          Args.push_back(ArgNode);

1206        } else {

1207          VarArgNH.mergeWith(ArgNode);

1208        }

1209      }

1210 

1211    // Add a newfunction call entry...

1212    if (CalleeNode) {

1213      ++NumIndirectCall;

1214     G.getFunctionCalls().push_back(DSCallSite(CS, RetVal, VarArgNH,CalleeNode,

1215                                               Args));

1216    } else {

1217      ++NumDirectCall;

1218      G.getFunctionCalls().push_back(DSCallSite(CS,RetVal, VarArgNH,

1219                                               cast<Function>(Callee),

1220                                               Args));

1221    }

1222 

1223 

1224  }

 

在DSGraph值专门有一个域FunctionCalls记录有关函数调用的DSA节点。这个域的类型是std::list<DSCallSite>，而类型DSCallSite有如下成员：

 

160      typedefstd::set<CallSite> MappedSites_t;

161    private:

162      CallSite        Site;               //Actual call site

163      constFunction *CalleeF;            // The functioncalled (direct call)

164      DSNodeHandle    CalleeN;            // Thefunction node called (indirect call)

165      DSNodeHandle    RetVal;             //Returned value

166      DSNodeHandle    VarArgVal;          // Mergedvar-arg val

167      std::vector<DSNodeHandle> CallArgs; // The pointer arguments

168      MappedSites_t MappedSites;          // Themerged callsites

 

这些成员的含义，注释已经说得很清楚。1214及1218行调用了下面这两个构造函数：

 

199      DSCallSite(CallSite CS, const DSNodeHandle &rv, constDSNodeHandle &va,

200                 DSNode *Callee,std::vector<DSNodeHandle> &Args)

201        : Site(CS), CalleeF(0), CalleeN(Callee),RetVal(rv), VarArgVal(va) {

202        assert(Callee&& "Null callee node specified for call site!");

203        Args.swap(CallArgs);

204      }

205      DSCallSite(CallSite CS, const DSNodeHandle &rv, constDSNodeHandle &va,

206                 constFunction *Callee, std::vector<DSNodeHandle> &Args)

207        : Site(CS), CalleeF(Callee), RetVal(rv),VarArgVal(va) {

208        assert(Callee&& "Null callee function specified for call site!");

209        Args.swap(CallArgs);

210      }

 

在1214行CalleeNode被设置到CalleeN，而在1218行，Callee被设置到CalleeF。

1.3.3.4.1.1.16. 对其他指令的处理

根据基类InstVisitor的安排，所有没有重载的visit*函数，都最终会进入visitInstruction函数。对于DSA，只关心Inst的类型。如果它是指针类型，意味着其返回值与其指针类型的操作数可能互为别名，于是将它们简并起来。

 

1229  void GraphBuilder::visitInstruction(Instruction&Inst) {

1230    DSNodeHandle CurNode;

1231    if (isa<PointerType>(Inst.getType()))

1232      CurNode = getValueDest(&Inst);

1233    for(User::op_iterator I = Inst.op_begin(), E = Inst.op_end(); I != E; ++I)

1234      if(isa<PointerType>((*I)->getType()))

1235        CurNode.mergeWith(getValueDest(*I));

1236 

1237    if (DSNode *N = CurNode.getNode())

1238      N->setUnknownMarker();

1239  }

 

如果CurNode不是指向null，把这个DSNode标记为unknown，而不是Incomplete。这是Chris在论文中强调过的。

相同，是宽度不小于8、不大于平台上限、为2的指数的整数，访问内存的指针必须指向这个类型。不管成功与否，AtomicCmpXchg指令都将返回指针所指向的值，因此AtomicCmpXchg指令的类型是由指针所指向值的类型决定。438~441行比较奇怪，参考visitAtomicRMWInst，似乎应该去掉 。

 

437    voidGraphBuilder::visitAtomicCmpXchgInst(AtomicCmpXchgInst &I) {

438      if (isa<PointerType>(I.getType())) {

439        visitInstruction (I);

440        return;

441      }

442   

443      //

444      // Create a DSNodefor the dereferenced pointer .  If theDSNode is NULL, do

445      // nothing more(this can occur if the pointer is a NULL constant; bugpoint

446      // can generatesuch code).

447      //

448      DSNodeHandle Ptr = getValueDest(I.getPointerOperand());

449      if (Ptr.isNull()) return;

450   

451      //

452      // Make that thememory object is read and written.

453      //

454      Ptr.getNode()->setReadMarker();

455      Ptr.getNode()->setModifiedMarker();

456   

457      //

458      // If the result ofthe compare-and-swap is a pointer, then we need to do

459      // a few things:

460      //  o Merge the compare and swap values (whichare pointers) with the result

461      //  o Merge the DSNode of the pointer *within*the memory object with the

462      //    DSNode of the compare, swap, and resultDSNode.

463      //

464      if (isa<PointerType>(I.getType())) {

465        //

466        // Get the DSNodeHandle of the memory objectreturned from the load.  Make

467        // it the DSNodeHandle of the instruction'sresult.

468        //

469        DSNodeHandle FieldPtr = getLink (Ptr);

470        setDestTo(I,getLink(Ptr));

471   

472        //

473        // Merge the result, compare, and swap valuesof the instruction.

474        //

475        FieldPtr.mergeWith(getValueDest (I.getCompareOperand()));

476        FieldPtr.mergeWith (getValueDest(I.getNewValOperand()));

477      }

478   

479      //

480      // Modify theDSNode so that it has the loaded/written type at the

481      // appropriateoffset.

482      //

483     Ptr.getNode()->growSizeForType(I.getType(), Ptr.getOffset());

484      Ptr.getNode()->mergeTypeInfo(I.getType(), Ptr.getOffset());

485      return;

486    }

 

如果指针所指向的值本身也是一个指针类型，该值与给定值及新值构成别名，因此需要把它们指向的对象的DSNode节点进行简并（475~476行）。

1.3.3.4.1.1.6. 对AtomicRMW指令的处理

AtomicRMW指令是原子性地从内存中载入一个值，修改，然后回写。指令返回内存的初值。修改操作由指令的参数指定。

 

488    void GraphBuilder::visitAtomicRMWInst(AtomicRMWInst&I) {

489      //

490      // Create a DSNodefor the dereferenced pointer .  If theDSNode is NULL, do

491      // nothing more(this can occur if the pointer is a NULL constant; bugpoint

492      // can generatesuch code).

493      //

494      DSNodeHandle Ptr = getValueDest(I.getPointerOperand());

495      if (Ptr.isNull()) return;

496   

497      //

498      // Make that thememory object is read and written.

499      //

500      Ptr.getNode()->setReadMarker();

501      Ptr.getNode()->setModifiedMarker();

502   

503      //

504      // Modify theDSNode so that it has the loaded/written type at the

505      // appropriateoffset.

506      //

507     Ptr.getNode()->growSizeForType(I.getType(), Ptr.getOffset());

508      Ptr.getNode()->mergeTypeInfo(I.getType(), Ptr.getOffset());

509      return;

510    }

 

同样，必须通过一个指针访问这个内存。指针指向对象的类型与指令本身的类型是一致的，但这个内存有可能是结构体的一部分，508行让这个结构体知道这个情况。

1.3.3.4.1.1.7. 对Return指令的处理

这是函数返回值的抽象。514行的FB是这个GraphBuilder所对应的Function实例，如果返回值是一个指针类型，把返回值节点与函数中代表返回语句的节点进行简并。

 

512    void GraphBuilder::visitReturnInst(ReturnInst&RI) {

513      if (RI.getNumOperands() &&isa<PointerType>(RI.getOperand(0)->getType()))

514        G.getOrCreateReturnNodeFor(*FB).mergeWith(getValueDest(RI.getOperand(0)));

515    }

 

DSGraph中的成员ReturnNodes（类型std::map<constFunction*, DSNodeHandle>）专门用于保存函数的返回值，上面的getOrCreateReturnNodeFor就是为该函数在ReturnNodes中返回对应的DSNodeHandle，如果不存在就新创建（不过，函数的GraphBuilder在构造函数中已经创建了ReturnNodes）。

显然，如果函数没有返回值（void），ReturnNodes将是空的。

1.3.3.4.1.1.8. 对变长参数的处理

CallSite在llvm中代表调用点。这里是对va_start的调用（va_start是llvm的内置函数，而不是定义为宏，参考clang，va_start被定义为__builtin_va_start）。va_start的一般调用形式为：va_start (ap, param)。

 

912    void GraphBuilder::visitVAStart(CallSite CS) {

913      // Build outDSNodes for the va_list depending on the target arch

914      // And assosiatethe right node with the VANode for this function

915      // so it can bemerged with the right arguments from callsites

916   

917      DSNodeHandle RetNH = getValueDest(CS.getArgument(0));

918   

919      if (DSNode *N = RetNH.getNode())

920        visitVAStartNode(N);

921    }

 

Va_start的第一个参数具有va_list*类型，va_start使得这个参数指向实参列表。上面为ap的实参创建在DSGraph中的代表——DSNode及DSNodeHandle。

在DSGraph中VANodes域专门为每个函数提供变长参数的绑定。VANodes的类型是std::map<const Function*, DSNodeHandle>，getVANodeFor返回在其中与指定Function*关联的DSNodeHandle。

VAArray则是GraphBuilder的成员，初始化为0。每个函数都有自己的GraphBuilder，因此VAArray实例是与函数对应的。它代表可变实参列表。在941行，va_start的ap实参指向了实参列表（VANH是DSNodeHandle，VAArray是DSNode，在DSA算法中DSNodeHandle视为指向DSNode的指针）。

 

922    void GraphBuilder::visitVAStartNode(DSNode*N) {

923      assert(N&& "Null node as argument");

924      assert(FB&& "No function for this graph?");

925      Module *M = FB->getParent();

926      assert(M&& "No module for function");

927      Triple TargetTriple(M->getTargetTriple());

928      Triple::ArchType Arch =TargetTriple.getArch();

929   

930      // Fetch theVANode associated with the func containing the call to va_start

931      DSNodeHandle & VANH =G.getVANodeFor(*FB);

932      // Make sure thisNodeHandle has a node to go with it

933      if (VANH.isNull()) VANH.mergeWith(createNode());

934   

935      // Create adsnode for an array of pointers to the VAInfo for this func

936      // We create onesuch array for each function analyzed, as all

937      // calls tova_start will populate their argument with the same data.

938      if (!VAArray) VAArray = createNode();

939      VAArray->setArrayMarker();

940      VAArray->foldNodeCompletely();

941      VAArray->setLink(0,VANH);

942   

943      //VAStartmodifies its argument

944     N->setModifiedMarker();

945   

946      // For thearchitectures we support, build dsnodes that match

947      // how we knowva_list is used.

948      switch (Arch){

949      caseTriple::x86:

950        // On x86, wehave:

951        // va_list as apointer to an array of pointers to the variable arguments

952        if (N->getSize() < 1)

953          N->growSize(1);

954        N->setLink(0, VAArray);

955        break;

956      caseTriple::x86_64:

957        // On x86_64,we have va_list as a struct {i32, i32, i8*, i8* }

958        // The firsti8* is where arguments generally go, but the second i8* can

959        // be used alsoto pass arguments by register.

960        // We modelthis by having both the i8*'s point to an array of pointers

961        // to thearguments.

962        if (N->getSize() < 24)

963          N->growSize(24); //sizeof the va_list struct mentioned above

964        N->setLink(8,VAArray); //first i8*

965        N->setLink(16,VAArray); //second i8*

966   

967        break;

968      default:

969        // FIXME: Fornow we abort if we don't know how to handle this arch

970        // Either addsupport for other architectures, or at least mark the

971        // nodesunknown/incomplete or whichever results in the correct

972        // conservativebehavior in the general case

973        assert(0&& "VAstart not supported on this architecture!");

974        //XXX: Thismight be good enough in those cases that we don't know

975        //what the archdoes

976       N->setIncompleteMarker()->setUnknownMarker()->foldNodeCompletely();

977      }

978   

979      // XXX: We usedto set the alloca marker for the DSNode passed to va_start.

980      // Seems to methat you could allocate the va_list on the heap, so ignoring

981      // for now.

982     N->setModifiedMarker()->setVAStartMarker();

983    }

 

接下来，让ap的实参指向这个实参列表，在这一块DSA目前只支持x86系列机器。对于32位的x86机器，va_list类型是指向变长实参指针数组的指针，而对于64位x86机器，va_list的类型则是{i32, i32, i8*, i8*}。这里的N代表ap的实参，因此952~955，962~965行都是在DSGraph中表示ap实参指向实参列表。

在使用va_start将ap与实参列表绑定后，通过va_arg指令获取下一个指定类型的实参的地址。va_arg指令的语法是：x = va_arg(ap, type)。

 

517    void GraphBuilder::visitVAArgInst(VAArgInst&I) {

518      Module *M = FB->getParent();

519      Triple TargetTriple(M->getTargetTriple());

520      Triple::ArchType Arch =TargetTriple.getArch();

521      switch(Arch){

522      caseTriple::x86_64: {

523        // On x86_64, wehave va_list as a struct {i32, i32, i8*, i8* }

524        // The first i8* is where argumentsgenerally go, but the second i8* can

525        // be used alsoto pass arguments by register.

526        // We modelthis by having both the i8*'s point to an array of pointers

527        // to thearguments.

528        DSNodeHandle Ptr = G.getVANodeFor(*FB);

529        DSNodeHandle Dest = getValueDest(&I);

530        if (Ptr.isNull()) return;

531   

532        // Make thatthe node is read and written

533       Ptr.getNode()->setReadMarker()->setModifiedMarker();

534   

535        // Not updatingtype info, as it is already a collapsed node

536   

537        if (isa<PointerType>(I.getType()))

538          Dest.mergeWith(Ptr);

539        return;

540      }

541   

542      default: {

543        assert(0&& "What frontend generates this?");

544        DSNodeHandle Ptr = getValueDest(I.getOperand(0));

545   

546        //FIXME: alsoupdates the argument

547        if (Ptr.isNull()) return;

548   

549        // Make thatthe node is read and written

550       Ptr.getNode()->setReadMarker()->setModifiedMarker();

551   

552        // Ensure atype record exists.

553        DSNode *PtrN = Ptr.getNode();

554        PtrN->mergeTypeInfo(I.getType(),Ptr.getOffset());

555   

556        if (isa<PointerType>(I.getType()))

557          setDestTo(I,getLink(Ptr));

558      }

559      }

560    }

 

因为前面看到，对于32位x86机器，va_list是指向变长实参指针数组的指针，而且这个数组实际上已经缩合了（visitVAStartNode的940行），因此，在这里不需要进一步的处理。对于64位x86机器，528行的Ptr是前面va_start的ap实参，它已经指向实参列表。在537行，va_arg的类型就是返回的实参的类型，如果该类型是指针，那么它也指向实参列表，这反映在538行与Ptr进行的简并。

而va_end，va_copy则在visitIntrinsic中处理。

1.3.3.4.1.1.9. 对intrinsic指令的处理

Llvm支持intrinsic函数的概念。这些函数都有广为人知的名字及语义，并要求遵循一定的约束。总之，这些intrinsic函数代表了llvm语言的一个扩展机制，在添加入语言（或字节码读写器，解析器等等）时，不需要改变llvm中所有的转换（transformation）。

Llvm定义了如下的intrinsic函数（详情参考llvm语言在线手册）：

Llvm.va_start，它的作用与C宏va_start相同。

Llvm.va_end，它的作用与C宏va_end相同，销毁va_start初始化的va_list。

Llvm.va_copy，它的作用与C宏va_copy相同，将源va_list拷贝到目标va_list。

Llvm.returnaddress，它返回表示指定调用框的返回地址的指针，在不能识别时，返回0。这仅用于调试。

Llvm.frameaddress，它返回表示指定调用框的框地址的指针，在不能识别时，返回0。这仅用于调试。

Llvm.stacksave，它返回一个可以传递给llvm.restore的不透明度的指针。当llvm.stackrestore以llvm.stacksave保存的值执行时，它实际上把栈恢复到执行llvm.stacksave时的状态。

Llvm.prefetch，它暗示代码生成器，如果支持，插入一个预取指令。

Llvm.lifetime.start，它表示在代码中该点之前，指定内存的值是无用的。这意味着已知该内存不会被用到且有未定义的值。

Llvm.lifetime.end，它表示在代码中该点之后，指定内存的值是无用的。这意味着已知该内存不会被用到且有未定义的值。

Llvm.invariant.start，它表示直到使用其返回值的llvm.invariant.end，期间所引用的内存位置是不变的。

Llvm.eh.typeid.for，它返回在当前函数异常表中的type info索引。

 

1000  bool GraphBuilder::visitIntrinsic(CallSiteCS, Function *F) {

1001    ++NumIntrinsicCall;

1002 

1003    //

1004    // If this is adebug intrinsic, then don't do any special processing.

1005    //

1006    if(isa<DbgInfoIntrinsic>(CS.getInstruction()))

1007      returntrue;

1008 

1009    switch(F->getIntrinsicID()) {

1010    caseIntrinsic::vastart: {

1011      visitVAStart(CS);

1012      returntrue;

1013    }

1014    caseIntrinsic::vacopy: {

1015      // Simply mergethe two arguments to va_copy.

1016      // This resultsin loss of precision on the temporaries used to manipulate

1017      // the va_list,and so isn't a big deal.  In theory wewould build a

1018      // separategraph for this (like the one created in visitVAStartNode)

1019      // and onlymerge the node containing the variable arguments themselves.

1020      DSNodeHandle destNH =getValueDest(CS.getArgument(0));

1021      DSNodeHandle srcNH = getValueDest(CS.getArgument(1));

1022      destNH.mergeWith(srcNH);

1023      returntrue;

1024    }

1025    caseIntrinsic::stacksave: {

1026      DSNode * Node = createNode();

1027     Node->setAllocaMarker()->setIncompleteMarker()->setUnknownMarker();

1028      Node->foldNodeCompletely();

1029      setDestTo(*(CS.getInstruction()), Node);

1030      returntrue;

1031    }

1032    caseIntrinsic::stackrestore:

1033      getValueDest(CS.getInstruction()).getNode()->setAllocaMarker()

1034        ->setIncompleteMarker()

1035        ->setUnknownMarker()

1036        ->foldNodeCompletely();

1037      returntrue;

1038    caseIntrinsic::vaend:

1039      // TODO: Whatto do here?

1040      returntrue;

1041    caseIntrinsic::memcpy:

1042    caseIntrinsic::memmove: {

1043      // Merge thefirst & second arguments, and mark the memory read and

1044      // modified.

1045      DSNodeHandle RetNH = getValueDest(CS.getArgument(0));

1046      RetNH.mergeWith(getValueDest(CS.getArgument(1)));

1047      if (DSNode *N = RetNH.getNode())

1048       N->setModifiedMarker()->setReadMarker();

1049      returntrue;

1050    }

1051    caseIntrinsic::memset:

1052      // Mark thememory modified.

1053      if (DSNode *N = getValueDest(CS.getArgument(0)).getNode())

1054        N->setModifiedMarker();

1055      returntrue;

1056 

1057      // TODO: Addsupport for the new EH system

1058  #if 0

1059    case Intrinsic::eh_exception: {

1060      DSNode * Node = createNode();

1061      Node->setIncompleteMarker();

1062      Node->foldNodeCompletely();

1063      setDestTo (*(CS.getInstruction()), Node);

1064      return true;

1065    }

1066 

1067    case Intrinsic::eh_selector: {

1068      for (CallSite::arg_iterator I =CS.arg_begin(), E = CS.arg_end();

1069           I != E; ++I) {

1070        if(isa<PointerType>((*I)->getType())) {

1071          DSNodeHandle Ptr = getValueDest(*I);

1072          if(Ptr.getNode()) {

1073            Ptr.getNode()->setReadMarker();

1074           Ptr.getNode()->setIncompleteMarker();

1075          }

1076        }

1077      }

1078      return true;

1079    }

1080  #endif

1081 

1082    caseIntrinsic::eh_typeid_for: {

1083      DSNodeHandle Ptr = getValueDest(CS.getArgument(0));

1084      Ptr.getNode()->setReadMarker();

1085      Ptr.getNode()->setIncompleteMarker();

1086      returntrue;

1087    }

1088 

1089    caseIntrinsic::prefetch:

1090      returntrue;

1091 

1092    caseIntrinsic::objectsize:

1093      returntrue;

1094 

1095      //

1096      // The returnaddress/frame address aliases with the stack,

1097      // istype-unknown, and should

1098      // have theunknown flag set since we don't know where it goes.

1099      //

1100    caseIntrinsic::returnaddress:

1101    caseIntrinsic::frameaddress: {

1102      DSNode * Node = createNode();

1103     Node->setAllocaMarker()->setIncompleteMarker()->setUnknownMarker();

1104     Node->foldNodeCompletely();

1105      setDestTo(*(CS.getInstruction()), Node);

1106      returntrue;

1107    }

1108 

1109    // Process lifetime intrinsics

1110    caseIntrinsic::lifetime_start:

1111    caseIntrinsic::lifetime_end:

1112    caseIntrinsic::invariant_start:

1113    caseIntrinsic::invariant_end:

1114      returntrue;

1115 

1116    default: {

1117      //ignorepointer free intrinsics

1118      if (!isa<PointerType>(F->getReturnType())){

1119        bool hasPtr = false;

1120        for(Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();

1121             I != E && !hasPtr; ++I)

1122          if(isa<PointerType>(I->getType()))

1123            hasPtr = true;

1124        if (!hasPtr)

1125          returntrue;

1126      }

1127 

1128      DEBUG(errs() << "[dsa:local]Unhandled intrinsic: " << F->getName() << "\n");

1129      assert(0&& "Unhandled intrinsic");

1130      returnfalse;

1131    }

1132    }

1133  }

 

注意1033行，llvm.stackrestore被视为通过alloca从栈上分配。