LatticeValue *SFVInstVisitor::getLatticeValueForField(Value *Ptr) { if (!isa<PointerType>(Ptr->getType()) || isa<ConstantPointerNull>(Ptr)) return 0; const DSNodeHandle *NH = &DSG.getNodeForValue(Ptr); DSNode *Node = NH->getNode(); assert(Node && "Pointer doesn't have node??"); std::multimap<DSNode*, LatticeValue*>::iterator I = NodeLVs.find(Node); if (I == NodeLVs.end()) return 0; // Not a node we are still tracking. // Okay, next convert the node offset to a field index expression. std::vector<unsigned> Idxs; ComputeStructureFieldIndices(Node->getType(), NH->getOffset(), Idxs, Node->getParentGraph()->getTargetData()); for (; I != NodeLVs.end() && I->first == Node; ++I) if (I->second->getIndices() == Idxs) return I->second; return 0; }
// Precondition: Enforce that the alloca nodes haven't been already converted void ConvertUnsafeAllocas::TransformAllocasToMallocs(std::list<DSNode *> & unsafeAllocaNodes) { std::list<DSNode *>::const_iterator iCurrent = unsafeAllocaNodes.begin(), iEnd = unsafeAllocaNodes.end(); for (; iCurrent != iEnd; ++iCurrent) { DSNode *DSN = *iCurrent; // Now change the alloca instruction corresponding to the node // to malloc DSGraph *DSG = DSN->getParentGraph(); DSGraph::ScalarMapTy &SM = DSG->getScalarMap(); #ifndef LLVA_KERNEL Instruction *MI = 0; #else Value *MI = 0; #endif for (DSGraph::ScalarMapTy::iterator SMI = SM.begin(), SME = SM.end(); SMI != SME; ) { bool stackAllocate = true; // If this is already a heap node, then you cannot allocate this on the // stack if (DSN->isHeapNode()) { stackAllocate = false; } if (SMI->second.getNode() == DSN) { if (AllocaInst *AI = dyn_cast<AllocaInst>((Value *)(SMI->first))) { // // Create a new heap allocation instruction. // if (AI->getParent() != 0) { // // Create an LLVM value representing the size of the allocation. // If it's an array allocation, we'll need to insert a // multiplication instruction to get the size times the number of // elements. // unsigned long size = TD->getTypeAllocSize(AI->getAllocatedType()); Value *AllocSize = ConstantInt::get(Int32Type, size); if (AI->isArrayAllocation()) AllocSize = BinaryOperator::Create(Instruction::Mul, AllocSize, AI->getOperand(0), "sizetmp", AI); std::vector<Value *> args(1, AllocSize); CallInst *CI = CallInst::Create (kmalloc, args.begin(), args.end(), "", AI); MI = castTo (CI, AI->getType(), "", AI); DSN->setHeapMarker(); AI->replaceAllUsesWith(MI); SM.erase(SMI++); AI->getParent()->getInstList().erase(AI); ++ConvAllocas; InsertFreesAtEnd(MI); #ifndef LLVA_KERNEL if (stackAllocate) { ArrayMallocs.insert(MI); } #endif } else { ++SMI; } } else { ++SMI; } } else { ++SMI; } } } }