void LowerInvoke::createAbortMessage(Module *M) { if (ExpensiveEHSupport) { // The abort message for expensive EH support tells the user that the // program 'unwound' without an 'invoke' instruction. Constant *Msg = ConstantArray::get(M->getContext(), "ERROR: Exception thrown, but not caught!\n"); AbortMessageLength = Msg->getNumOperands()-1; // don't include \0 GlobalVariable *MsgGV = new GlobalVariable(*M, Msg->getType(), true, GlobalValue::InternalLinkage, Msg, "abortmsg"); std::vector<Constant*> GEPIdx(2, Constant::getNullValue(Type::getInt32Ty(M->getContext()))); AbortMessage = ConstantExpr::getGetElementPtr(MsgGV, &GEPIdx[0], 2); } else { // The abort message for cheap EH support tells the user that EH is not // enabled. Constant *Msg = ConstantArray::get(M->getContext(), "Exception handler needed, but not enabled." "Recompile program with -enable-correct-eh-support.\n"); AbortMessageLength = Msg->getNumOperands()-1; // don't include \0 GlobalVariable *MsgGV = new GlobalVariable(*M, Msg->getType(), true, GlobalValue::InternalLinkage, Msg, "abortmsg"); std::vector<Constant*> GEPIdx(2, Constant::getNullValue( Type::getInt32Ty(M->getContext()))); AbortMessage = ConstantExpr::getGetElementPtr(MsgGV, &GEPIdx[0], 2); } }
void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageData) { CoverageData->setSection(getCoverageSection()); CoverageData->setAlignment(8); Constant *Init = CoverageData->getInitializer(); // We're expecting { i32, i32, i32, i32, [n x { i8*, i32, i32 }], [m x i8] } // for some C. If not, the frontend's given us something broken. assert(Init->getNumOperands() == 6 && "bad number of fields in coverage map"); assert(isa<ConstantArray>(Init->getAggregateElement(4)) && "invalid function list in coverage map"); ConstantArray *Records = cast<ConstantArray>(Init->getAggregateElement(4)); for (unsigned I = 0, E = Records->getNumOperands(); I < E; ++I) { Constant *Record = Records->getOperand(I); Value *V = const_cast<Value *>(Record->getOperand(0))->stripPointerCasts(); assert(isa<GlobalVariable>(V) && "Missing reference to function name"); GlobalVariable *Name = cast<GlobalVariable>(V); // If we have region counters for this name, we've already handled it. auto It = RegionCounters.find(Name); if (It != RegionCounters.end()) continue; // Move the name variable to the right section. Name->setSection(getNameSection()); Name->setAlignment(1); } }
Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags, ValueMapTypeRemapper *TypeMapper, ValueMaterializer *Materializer) { ValueToValueMapTy::iterator I = VM.find(V); // If the value already exists in the map, use it. if (I != VM.end() && I->second) return I->second; // If we have a materializer and it can materialize a value, use that. if (Materializer) { if (Value *NewV = Materializer->materializeValueFor(const_cast<Value*>(V))) return VM[V] = NewV; } // Global values do not need to be seeded into the VM if they // are using the identity mapping. if (isa<GlobalValue>(V)) return VM[V] = const_cast<Value*>(V); if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { // Inline asm may need *type* remapping. FunctionType *NewTy = IA->getFunctionType(); if (TypeMapper) { NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy)); if (NewTy != IA->getFunctionType()) V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(), IA->hasSideEffects(), IA->isAlignStack()); } return VM[V] = const_cast<Value*>(V); } if (const auto *MDV = dyn_cast<MetadataAsValue>(V)) { const Metadata *MD = MDV->getMetadata(); // If this is a module-level metadata and we know that nothing at the module // level is changing, then use an identity mapping. if (!isa<LocalAsMetadata>(MD) && (Flags & RF_NoModuleLevelChanges)) return VM[V] = const_cast<Value *>(V); auto *MappedMD = MapMetadata(MD, VM, Flags, TypeMapper, Materializer); if (MD == MappedMD || (!MappedMD && (Flags & RF_IgnoreMissingEntries))) return VM[V] = const_cast<Value *>(V); // FIXME: This assert crashes during bootstrap, but I think it should be // correct. For now, just match behaviour from before the metadata/value // split. // // assert(MappedMD && "Referenced metadata value not in value map"); return VM[V] = MetadataAsValue::get(V->getContext(), MappedMD); } // Okay, this either must be a constant (which may or may not be mappable) or // is something that is not in the mapping table. Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); if (!C) return nullptr; if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) { Function *F = cast<Function>(MapValue(BA->getFunction(), VM, Flags, TypeMapper, Materializer)); BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(), VM, Flags, TypeMapper, Materializer)); return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock()); } // Otherwise, we have some other constant to remap. Start by checking to see // if all operands have an identity remapping. unsigned OpNo = 0, NumOperands = C->getNumOperands(); Value *Mapped = nullptr; for (; OpNo != NumOperands; ++OpNo) { Value *Op = C->getOperand(OpNo); Mapped = MapValue(Op, VM, Flags, TypeMapper, Materializer); if (Mapped != C) break; } // See if the type mapper wants to remap the type as well. Type *NewTy = C->getType(); if (TypeMapper) NewTy = TypeMapper->remapType(NewTy); // If the result type and all operands match up, then just insert an identity // mapping. if (OpNo == NumOperands && NewTy == C->getType()) return VM[V] = C; // Okay, we need to create a new constant. We've already processed some or // all of the operands, set them all up now. SmallVector<Constant*, 8> Ops; Ops.reserve(NumOperands); for (unsigned j = 0; j != OpNo; ++j) Ops.push_back(cast<Constant>(C->getOperand(j))); // If one of the operands mismatch, push it and the other mapped operands. if (OpNo != NumOperands) { Ops.push_back(cast<Constant>(Mapped)); // Map the rest of the operands that aren't processed yet. for (++OpNo; OpNo != NumOperands; ++OpNo) Ops.push_back(MapValue(cast<Constant>(C->getOperand(OpNo)), VM, Flags, TypeMapper, Materializer)); } if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) return VM[V] = CE->getWithOperands(Ops, NewTy); if (isa<ConstantArray>(C)) return VM[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops); if (isa<ConstantStruct>(C)) return VM[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops); if (isa<ConstantMemberPointer>(C)) return VM[V] = ConstantMemberPointer::get(cast<StructType>(NewTy), Ops, dyn_cast<ConstantMemberPointer>(C)->getClassName()); if (isa<ConstantVector>(C)) return VM[V] = ConstantVector::get(Ops); // If this is a no-operand constant, it must be because the type was remapped. if (isa<UndefValue>(C)) return VM[V] = UndefValue::get(NewTy); if (isa<ConstantAggregateZero>(C)) return VM[V] = ConstantAggregateZero::get(NewTy); assert(isa<ConstantPointerNull>(C)); return VM[V] = ConstantPointerNull::get(cast<PointerType>(NewTy)); }
Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags, ValueMapTypeRemapper *TypeMapper) { ValueToValueMapTy::iterator I = VM.find(V); // If the value already exists in the map, use it. if (I != VM.end() && I->second) return I->second; // Global values do not need to be seeded into the VM if they // are using the identity mapping. if (isa<GlobalValue>(V) || isa<MDString>(V)) return VM[V] = const_cast<Value*>(V); if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { // Inline asm may need *type* remapping. FunctionType *NewTy = IA->getFunctionType(); if (TypeMapper) { NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy)); if (NewTy != IA->getFunctionType()) V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(), IA->hasSideEffects(), IA->isAlignStack()); } return VM[V] = const_cast<Value*>(V); } if (const MDNode *MD = dyn_cast<MDNode>(V)) { // If this is a module-level metadata and we know that nothing at the module // level is changing, then use an identity mapping. if (!MD->isFunctionLocal() && (Flags & RF_NoModuleLevelChanges)) return VM[V] = const_cast<Value*>(V); // Create a dummy node in case we have a metadata cycle. MDNode *Dummy = MDNode::getTemporary(V->getContext(), ArrayRef<Value*>()); VM[V] = Dummy; // Check all operands to see if any need to be remapped. for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) { Value *OP = MD->getOperand(i); if (OP == 0 || MapValue(OP, VM, Flags, TypeMapper) == OP) continue; // Ok, at least one operand needs remapping. SmallVector<Value*, 4> Elts; Elts.reserve(MD->getNumOperands()); for (i = 0; i != e; ++i) { Value *Op = MD->getOperand(i); Elts.push_back(Op ? MapValue(Op, VM, Flags, TypeMapper) : 0); } MDNode *NewMD = MDNode::get(V->getContext(), Elts); Dummy->replaceAllUsesWith(NewMD); VM[V] = NewMD; MDNode::deleteTemporary(Dummy); return NewMD; } VM[V] = const_cast<Value*>(V); MDNode::deleteTemporary(Dummy); // No operands needed remapping. Use an identity mapping. return const_cast<Value*>(V); } // Okay, this either must be a constant (which may or may not be mappable) or // is something that is not in the mapping table. Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); if (C == 0) return 0; if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) { Function *F = cast<Function>(MapValue(BA->getFunction(), VM, Flags, TypeMapper)); BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(), VM, Flags, TypeMapper)); return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock()); } // Otherwise, we have some other constant to remap. Start by checking to see // if all operands have an identity remapping. unsigned OpNo = 0, NumOperands = C->getNumOperands(); Value *Mapped = 0; for (; OpNo != NumOperands; ++OpNo) { Value *Op = C->getOperand(OpNo); Mapped = MapValue(Op, VM, Flags, TypeMapper); if (Mapped != C) break; } // See if the type mapper wants to remap the type as well. Type *NewTy = C->getType(); if (TypeMapper) NewTy = TypeMapper->remapType(NewTy); // If the result type and all operands match up, then just insert an identity // mapping. if (OpNo == NumOperands && NewTy == C->getType()) return VM[V] = C; // Okay, we need to create a new constant. We've already processed some or // all of the operands, set them all up now. SmallVector<Constant*, 8> Ops; Ops.reserve(NumOperands); for (unsigned j = 0; j != OpNo; ++j) Ops.push_back(cast<Constant>(C->getOperand(j))); // If one of the operands mismatch, push it and the other mapped operands. if (OpNo != NumOperands) { Ops.push_back(cast<Constant>(Mapped)); // Map the rest of the operands that aren't processed yet. for (++OpNo; OpNo != NumOperands; ++OpNo) Ops.push_back(MapValue(cast<Constant>(C->getOperand(OpNo)), VM, Flags, TypeMapper)); } if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) return VM[V] = CE->getWithOperands(Ops, NewTy); if (isa<ConstantArray>(C)) return VM[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops); if (isa<ConstantStruct>(C)) return VM[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops); if (isa<ConstantVector>(C)) return VM[V] = ConstantVector::get(Ops); // If this is a no-operand constant, it must be because the type was remapped. if (isa<UndefValue>(C)) return VM[V] = UndefValue::get(NewTy); if (isa<ConstantAggregateZero>(C)) return VM[V] = ConstantAggregateZero::get(NewTy); assert(isa<ConstantPointerNull>(C)); return VM[V] = ConstantPointerNull::get(cast<PointerType>(NewTy)); }
Value *Mapper::mapValue(const Value *V) { ValueToValueMapTy::iterator I = getVM().find(V); // If the value already exists in the map, use it. if (I != getVM().end()) { assert(I->second && "Unexpected null mapping"); return I->second; } // If we have a materializer and it can materialize a value, use that. if (auto *Materializer = getMaterializer()) { if (Value *NewV = Materializer->materialize(const_cast<Value *>(V))) { getVM()[V] = NewV; return NewV; } } // Global values do not need to be seeded into the VM if they // are using the identity mapping. if (isa<GlobalValue>(V)) { if (Flags & RF_NullMapMissingGlobalValues) return nullptr; return getVM()[V] = const_cast<Value *>(V); } if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) { // Inline asm may need *type* remapping. FunctionType *NewTy = IA->getFunctionType(); if (TypeMapper) { NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy)); if (NewTy != IA->getFunctionType()) V = InlineAsm::get(NewTy, IA->getAsmString(), IA->getConstraintString(), IA->hasSideEffects(), IA->isAlignStack()); } return getVM()[V] = const_cast<Value *>(V); } if (const auto *MDV = dyn_cast<MetadataAsValue>(V)) { const Metadata *MD = MDV->getMetadata(); if (auto *LAM = dyn_cast<LocalAsMetadata>(MD)) { // Look through to grab the local value. if (Value *LV = mapValue(LAM->getValue())) { if (V == LAM->getValue()) return const_cast<Value *>(V); return MetadataAsValue::get(V->getContext(), ValueAsMetadata::get(LV)); } // FIXME: always return nullptr once Verifier::verifyDominatesUse() // ensures metadata operands only reference defined SSA values. return (Flags & RF_IgnoreMissingLocals) ? nullptr : MetadataAsValue::get(V->getContext(), MDTuple::get(V->getContext(), None)); } // If this is a module-level metadata and we know that nothing at the module // level is changing, then use an identity mapping. if (Flags & RF_NoModuleLevelChanges) return getVM()[V] = const_cast<Value *>(V); // Map the metadata and turn it into a value. auto *MappedMD = mapMetadata(MD); if (MD == MappedMD) return getVM()[V] = const_cast<Value *>(V); return getVM()[V] = MetadataAsValue::get(V->getContext(), MappedMD); } // Okay, this either must be a constant (which may or may not be mappable) or // is something that is not in the mapping table. Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); if (!C) return nullptr; if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) return mapBlockAddress(*BA); auto mapValueOrNull = [this](Value *V) { auto Mapped = mapValue(V); assert((Mapped || (Flags & RF_NullMapMissingGlobalValues)) && "Unexpected null mapping for constant operand without " "NullMapMissingGlobalValues flag"); return Mapped; }; // Otherwise, we have some other constant to remap. Start by checking to see // if all operands have an identity remapping. unsigned OpNo = 0, NumOperands = C->getNumOperands(); Value *Mapped = nullptr; for (; OpNo != NumOperands; ++OpNo) { Value *Op = C->getOperand(OpNo); Mapped = mapValueOrNull(Op); if (!Mapped) return nullptr; if (Mapped != Op) break; } // See if the type mapper wants to remap the type as well. Type *NewTy = C->getType(); if (TypeMapper) NewTy = TypeMapper->remapType(NewTy); // If the result type and all operands match up, then just insert an identity // mapping. if (OpNo == NumOperands && NewTy == C->getType()) return getVM()[V] = C; // Okay, we need to create a new constant. We've already processed some or // all of the operands, set them all up now. SmallVector<Constant*, 8> Ops; Ops.reserve(NumOperands); for (unsigned j = 0; j != OpNo; ++j) Ops.push_back(cast<Constant>(C->getOperand(j))); // If one of the operands mismatch, push it and the other mapped operands. if (OpNo != NumOperands) { Ops.push_back(cast<Constant>(Mapped)); // Map the rest of the operands that aren't processed yet. for (++OpNo; OpNo != NumOperands; ++OpNo) { Mapped = mapValueOrNull(C->getOperand(OpNo)); if (!Mapped) return nullptr; Ops.push_back(cast<Constant>(Mapped)); } } Type *NewSrcTy = nullptr; if (TypeMapper) if (auto *GEPO = dyn_cast<GEPOperator>(C)) NewSrcTy = TypeMapper->remapType(GEPO->getSourceElementType()); if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) return getVM()[V] = CE->getWithOperands(Ops, NewTy, false, NewSrcTy); if (isa<ConstantArray>(C)) return getVM()[V] = ConstantArray::get(cast<ArrayType>(NewTy), Ops); if (isa<ConstantStruct>(C)) return getVM()[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops); if (isa<ConstantVector>(C)) return getVM()[V] = ConstantVector::get(Ops); // If this is a no-operand constant, it must be because the type was remapped. if (isa<UndefValue>(C)) return getVM()[V] = UndefValue::get(NewTy); if (isa<ConstantAggregateZero>(C)) return getVM()[V] = ConstantAggregateZero::get(NewTy); assert(isa<ConstantPointerNull>(C)); return getVM()[V] = ConstantPointerNull::get(cast<PointerType>(NewTy)); }
Value *llvm::MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags) { ValueToValueMapTy::iterator I = VM.find(V); // If the value already exists in the map, use it. if (I != VM.end() && I->second) return I->second; // Global values do not need to be seeded into the VM if they // are using the identity mapping. if (isa<GlobalValue>(V) || isa<InlineAsm>(V) || isa<MDString>(V)) return VM[V] = const_cast<Value*>(V); if (const MDNode *MD = dyn_cast<MDNode>(V)) { // If this is a module-level metadata and we know that nothing at the module // level is changing, then use an identity mapping. if (!MD->isFunctionLocal() && (Flags & RF_NoModuleLevelChanges)) return VM[V] = const_cast<Value*>(V); // Create a dummy node in case we have a metadata cycle. MDNode *Dummy = MDNode::getTemporary(V->getContext(), 0, 0); VM[V] = Dummy; // Check all operands to see if any need to be remapped. for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i) { Value *OP = MD->getOperand(i); if (OP == 0 || MapValue(OP, VM, Flags) == OP) continue; // Ok, at least one operand needs remapping. SmallVector<Value*, 4> Elts; Elts.reserve(MD->getNumOperands()); for (i = 0; i != e; ++i) { Value *Op = MD->getOperand(i); Elts.push_back(Op ? MapValue(Op, VM, Flags) : 0); } MDNode *NewMD = MDNode::get(V->getContext(), Elts.data(), Elts.size()); Dummy->replaceAllUsesWith(NewMD); VM[V] = NewMD; MDNode::deleteTemporary(Dummy); return NewMD; } VM[V] = const_cast<Value*>(V); MDNode::deleteTemporary(Dummy); // No operands needed remapping. Use an identity mapping. return const_cast<Value*>(V); } // Okay, this either must be a constant (which may or may not be mappable) or // is something that is not in the mapping table. Constant *C = const_cast<Constant*>(dyn_cast<Constant>(V)); if (C == 0) return 0; if (BlockAddress *BA = dyn_cast<BlockAddress>(C)) { Function *F = cast<Function>(MapValue(BA->getFunction(), VM, Flags)); BasicBlock *BB = cast_or_null<BasicBlock>(MapValue(BA->getBasicBlock(), VM, Flags)); return VM[V] = BlockAddress::get(F, BB ? BB : BA->getBasicBlock()); } for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { Value *Op = C->getOperand(i); Value *Mapped = MapValue(Op, VM, Flags); if (Mapped == C) continue; // Okay, the operands don't all match. We've already processed some or all // of the operands, set them up now. std::vector<Constant*> Ops; Ops.reserve(C->getNumOperands()); for (unsigned j = 0; j != i; ++j) Ops.push_back(cast<Constant>(C->getOperand(i))); Ops.push_back(cast<Constant>(Mapped)); // Map the rest of the operands that aren't processed yet. for (++i; i != e; ++i) Ops.push_back(cast<Constant>(MapValue(C->getOperand(i), VM, Flags))); if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) return VM[V] = CE->getWithOperands(Ops); if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) return VM[V] = ConstantArray::get(CA->getType(), Ops); if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) return VM[V] = ConstantStruct::get(CS->getType(), Ops); assert(isa<ConstantVector>(C) && "Unknown mapped constant type"); return VM[V] = ConstantVector::get(Ops); } // If we reach here, all of the operands of the constant match. return VM[V] = C; }
DyckVertex* AAAnalyzer::wrapValue(Value * v) { // if the vertex of v exists, return it, otherwise create one pair < DyckVertex*, bool> retpair = dgraph->retrieveDyckVertex(v); if (retpair.second) { return retpair.first; } DyckVertex* vdv = retpair.first; // constantTy are handled as below. if (isa<ConstantExpr>(v)) { // constant expr should be handled like a assignment instruction if (isa<GEPOperator>(v)) { DyckVertex * got = handle_gep((GEPOperator*) v); makeAlias(vdv, got); } else if (((ConstantExpr*) v)->isCast()) { // errs() << *v << "\n"; DyckVertex * got = wrapValue(((ConstantExpr*) v)->getOperand(0)); makeAlias(vdv, got); } else { unsigned opcode = ((ConstantExpr*) v)->getOpcode(); switch (opcode) { case 23: // BinaryConstantExpr "and" case 24: // BinaryConstantExpr "or" { // do nothing } break; default: { errs() << "ERROR when handle the following constant expression\n"; errs() << *v << "\n"; errs() << ((ConstantExpr*) v)->getOpcode() << "\n"; errs() << ((ConstantExpr*) v)->getOpcodeName() << "\n"; errs().flush(); exit(-1); } break; } } } else if (isa<ConstantArray>(v)) { #ifndef ARRAY_SIMPLIFIED DyckVertex* ptr = addPtrTo(NULL, vdv, dgraph); DyckVertex* current = ptr; Constant * vAgg = (Constant*) v; int numElmt = vAgg->getNumOperands(); for (int i = 0; i < numElmt; i++) { Value * vi = vAgg->getOperand(i); DyckVertex* viptr = addPtrOffset(current, i * dl.getTypeAllocSize(vi->getType()), dgraph); addPtrTo(viptr, wrapValue(vi, dgraph, dl), dgraph); } #else Constant * vAgg = (Constant*) v; int numElmt = vAgg->getNumOperands(); for (int i = 0; i < numElmt; i++) { Value * vi = vAgg->getOperand(i); makeAlias(vdv, wrapValue(vi)); } #endif } else if (isa<ConstantStruct>(v)) { //DyckVertex* ptr = addPtrTo(NULL, vdv); //DyckVertex* current = ptr; Constant * vAgg = (Constant*) v; int numElmt = vAgg->getNumOperands(); for (int i = 0; i < numElmt; i++) { Value * vi = vAgg->getOperand(i); addField(vdv, -2 - i, wrapValue(vi)); } } else if (isa<GlobalValue>(v)) { if (isa<GlobalVariable>(v)) { GlobalVariable * global = (GlobalVariable *) v; if (global->hasInitializer()) { Value * initializer = global->getInitializer(); if (!isa<UndefValue>(initializer)) { DyckVertex * initVer = wrapValue(initializer); addPtrTo(vdv, initVer); } } } else if (isa<GlobalAlias>(v)) { GlobalAlias * global = (GlobalAlias *) v; Value * aliasee = global->getAliasee(); makeAlias(vdv, wrapValue(aliasee)); } else if (isa<Function>(v)) { // do nothing } // no else } else if (isa<ConstantInt>(v) || isa<ConstantFP>(v) || isa<ConstantPointerNull>(v) || isa<UndefValue>(v)) { // do nothing } else if (isa<ConstantDataArray>(v) || isa<ConstantAggregateZero>(v)) { // do nothing } else if (isa<BlockAddress>(v)) { // do nothing } else if (isa<ConstantDataVector>(v)) { errs() << "ERROR when handle the following ConstantDataSequential, ConstantDataVector\n"; errs() << *v << "\n"; errs().flush(); exit(-1); } else if (isa<ConstantVector>(v)) { errs() << "ERROR when handle the following ConstantVector\n"; errs() << *v << "\n"; errs().flush(); exit(-1); } else if (isa<Constant>(v)) { errs() << "ERROR when handle the following constant value\n"; errs() << *v << "\n"; errs().flush(); exit(-1); } return vdv; }