| /external/llvm/include/llvm/Analysis/ |
| FindUsedTypes.h | 48 void IncorporateType(Type *Ty);
|
| ScalarEvolutionExpander.h | 109 PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
123 Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I);
171 /// ReuseOrCreateCast - Arange for there to be a cast of V to Ty at IP,
175 Value *ReuseOrCreateCast(Value *V, Type *Ty,
182 Value *InsertNoopCastOfTo(Value *V, Type *Ty);
188 PointerType *PTy, Type *Ty, Value *V);
196 Value *expandCodeFor(const SCEV *SH, Type *Ty = 0);
|
| /external/llvm/lib/Analysis/IPA/ |
| FindUsedTypes.cpp | 32 void FindUsedTypes::IncorporateType(Type *Ty) {
33 // If ty doesn't already exist in the used types map, add it now, otherwise
35 if (!UsedTypes.insert(Ty)) return; // Already contain Ty.
39 for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
|
| /external/llvm/include/llvm/CodeGen/ |
| MachineConstantPool.h | 37 Type *Ty;
40 explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
45 Type *getType() const { return Ty; }
|
| MachineFunction.h | 209 template<typename Ty>
210 Ty *getInfo() {
212 // This should be just `new (Allocator.Allocate<Ty>()) Ty(*this)', but
214 Ty *Loc = static_cast<Ty*>(Allocator.Allocate(sizeof(Ty),
215 AlignOf<Ty>::Alignment));
216 MFInfo = new (Loc) Ty(*this);
218 return static_cast<Ty*>(MFInfo)
[all...] |
| /external/llvm/unittests/VMCore/ |
| VerifierTest.cpp | 50 Type *Ty = Type::getInt8Ty(C);
51 Constant *Init = Constant::getNullValue(Ty);
52 GlobalVariable *Aliasee = new GlobalVariable(M, Ty, true,
|
| /external/llvm/lib/Analysis/ |
| ScalarEvolutionExpander.cpp | 26 /// ReuseOrCreateCast - Arrange for there to be a cast of V to Ty at IP,
30 Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
37 if (U->getType() == Ty)
45 Instruction *NewCI = CastInst::Create(Op, V, Ty, "", IP);
58 Instruction *I = CastInst::Create(Op, V, Ty, V->getName(), IP);
66 Value *SCEVExpander::InsertNoopCastOfTo(Value *V, Type *Ty) {
67 Instruction::CastOps Op = CastInst::getCastOpcode(V, false, Ty, false);
72 assert(SE.getTypeSizeInBits(V->getType()) == SE.getTypeSizeInBits(Ty) &&
76 if (Op == Instruction::BitCast && V->getType() == Ty)
81 SE.getTypeSizeInBits(Ty) == SE.getTypeSizeInBits(V->getType()))
[all...] |
| ConstantFolding.cpp | 451 Type *Ty = cast<PointerType>(CE->getType())->getElementType();
452 unsigned NumBits = Ty->getPrimitiveSizeInBits();
456 (isa<IntegerType>(Ty) || Ty->isFloatingPointTy())) {
475 if (Ty->isFloatingPointTy())
476 Res = ConstantExpr::getBitCast(Res, Ty);
655 Type *Ty = Ptr->getType();
658 if (SequentialType *ATy = dyn_cast<SequentialType>(Ty)) {
671 IntegerType *IntPtrTy = TD->getIntPtrType(Ty->getContext());
673 // The element size is 0. This may be [0 x Ty]*, so just use a zer
[all...] |
| /external/llvm/include/llvm/ |
| InstrTypes.h | 37 TerminatorInst(Type *Ty, Instruction::TermOps iType,
40 : Instruction(Ty, iType, Ops, NumOps, InsertBefore) {}
42 TerminatorInst(Type *Ty, Instruction::TermOps iType,
44 : Instruction(Ty, iType, Ops, NumOps, InsertAtEnd) {}
94 UnaryInstruction(Type *Ty, unsigned iType, Value *V,
96 : Instruction(Ty, iType, &Op<0>(), 1, IB) {
99 UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
100 : Instruction(Ty, iType, &Op<0>(), 1, IAE) {
144 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
146 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
[all...] |
| Argument.h | 42 explicit Argument(Type *Ty, const Twine &Name = "", Function *F = 0);
|
| /external/llvm/lib/VMCore/ |
| Instructions.cpp | 836 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize,
838 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
839 getAISize(Ty->getContext(), ArraySize), InsertBefore) {
841 assert(!Ty->isVoidTy() && "Cannot allocate void!");
845 AllocaInst::AllocaInst(Type *Ty, Value *ArraySize,
847 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca,
848 getAISize(Ty->getContext(), ArraySize), InsertAtEnd) {
850 assert(!Ty->isVoidTy() && "Cannot allocate void!");
854 AllocaInst::AllocaInst(Type *Ty, const Twine &Name,
856 : UnaryInstruction(PointerType::getUnqual(Ty), Alloca
[all...] |
| InlineAsm.cpp | 28 InlineAsm *InlineAsm::get(FunctionType *Ty, StringRef AsmString,
32 LLVMContextImpl *pImpl = Ty->getContext().pImpl;
33 return pImpl->InlineAsms.getOrCreate(PointerType::getUnqual(Ty), Key);
36 InlineAsm::InlineAsm(PointerType *Ty, const std::string &asmString,
39 : Value(Ty, Value::InlineAsmVal),
245 bool InlineAsm::Verify(FunctionType *Ty, StringRef ConstStr) {
246 if (Ty->isVarArg()) return false;
279 if (!Ty->getReturnType()->isVoidTy()) return false;
282 if (Ty->getReturnType()->isStructTy()) return false;
285 StructType *STy = dyn_cast<StructType>(Ty->getReturnType())
[all...] |
| ConstantsContext.h | 39 UnaryConstantExpr(unsigned Opcode, Constant *C, Type *Ty)
40 : ConstantExpr(Ty, Opcode, &Op<0>(), 1) {
231 CompareConstantExpr(Type *ty, Instruction::OtherOps opc,
233 : ConstantExpr(ty, opc, &Op<0>(), 2), predicate(pred) {
395 static ConstantClass *create(TypeClass *Ty, const ValType &V) {
396 return new(ConstantTraits<ValType>::uses(V)) ConstantClass(Ty, V);
410 static ConstantExpr *create(Type *Ty, const ExprMapKeyType &V,
413 return new UnaryConstantExpr(V.opcode, V.operands[0], Ty);
431 V.indices, Ty);
433 return new ExtractValueConstantExpr(V.operands[0], V.indices, Ty);
[all...] |
| Module.cpp | 140 FunctionType *Ty,
146 Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
158 Constant *NewF = getOrInsertFunction(Name, Ty);
165 if (F->getType() != PointerType::getUnqual(Ty))
166 return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
173 FunctionType *Ty,
179 Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
190 FunctionType *Ty) {
192 return getOrInsertFunction(Name, Ty, AttributeList);
270 Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
[all...] |
| Globals.cpp | 83 GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link,
86 : GlobalValue(PointerType::get(Ty, AddressSpace),
92 assert(InitVal->getType() == Ty &&
100 GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,
105 : GlobalValue(PointerType::get(Ty, AddressSpace),
111 assert(InitVal->getType() == Ty &&
189 GlobalAlias::GlobalAlias(Type *Ty, LinkageTypes Link,
192 : GlobalValue(Ty, Value::GlobalAliasVal, &Op<0>(), 1, Link, Name) {
196 assert(aliasee->getType() == Ty && "Alias and aliasee types should match!");
|
| /external/clang/lib/CodeGen/ |
| CGBuiltin.cpp | 48 llvm::FunctionType *Ty =
51 return GetOrCreateLLVMFunction(Name, Ty, D, /*ForVTable=*/false);
338 Value *Ty = EmitScalarExpr(E->getArg(1));
339 ConstantInt *CI = dyn_cast<ConstantInt>(Ty);
472 llvm::Type *Ty = ConvertType(E->getArg(5)->getType());
484 Value *IsZero = Builder.CreateFCmpOEQ(V, Constant::getNullValue(Ty),
659 llvm::IntegerType *Ty
664 return RValue::get(llvm::UndefValue::get(Ty));
666 return RValue::get(llvm::ConstantInt::get(Ty, Column, true));
[all...] |
| CGCXX.cpp | 295 llvm::Value *This, llvm::Type *Ty) {
296 Ty = Ty->getPointerTo()->getPointerTo();
298 llvm::Value *VTable = CGF.GetVTablePtr(This, Ty);
306 llvm::Type *Ty) {
310 return ::BuildVirtualCall(*this, VTableIndex, This, Ty);
319 llvm::Type *Ty) {
334 Ty = Ty->getPointerTo()->getPointerTo();
335 VTable = Builder.CreateBitCast(VTable, Ty);
[all...] |
| TargetInfo.h | 113 llvm::Type* Ty) const {
114 return Ty;
|
| /external/llvm/include/llvm/ADT/ |
| STLExtras.h | 32 template<class Ty>
33 struct less_ptr : public std::binary_function<Ty, Ty, bool> {
34 bool operator()(const Ty* left, const Ty* right) const {
39 template<class Ty>
40 struct greater_ptr : public std::binary_function<Ty, Ty, bool> {
41 bool operator()(const Ty* left, const Ty* right) const
[all...] |
| /external/llvm/lib/Transforms/Scalar/ |
| GlobalMerge.cpp | 140 Type *Ty = Globals[j]->getType()->getElementType();
141 MergedSize += TD->getTypeAllocSize(Ty);
145 Tys.push_back(Ty);
186 Type *Ty = I->getType()->getElementType();
187 if (Alignment > TD->getABITypeAlignment(Ty))
195 if (TD->getTypeAllocSize(Ty) < MaxOffset) {
|
| /external/llvm/bindings/ocaml/executionengine/ |
| executionengine_ocaml.c | 87 CAMLprim value llvm_genericvalue_of_float(LLVMTypeRef Ty, value N) {
90 LLVMCreateGenericValueOfFloat(Ty, Double_val(N))));
100 CAMLprim value llvm_genericvalue_of_int(LLVMTypeRef Ty, value Int) {
101 return alloc_generic_value(LLVMCreateGenericValueOfInt(Ty, Int_val(Int), 1));
105 CAMLprim value llvm_genericvalue_of_int32(LLVMTypeRef Ty, value Int32) {
108 LLVMCreateGenericValueOfInt(Ty, Int32_val(Int32), 1)));
112 CAMLprim value llvm_genericvalue_of_nativeint(LLVMTypeRef Ty, value NatInt) {
115 LLVMCreateGenericValueOfInt(Ty, Nativeint_val(NatInt), 1)));
119 CAMLprim value llvm_genericvalue_of_int64(LLVMTypeRef Ty, value Int64) {
122 LLVMCreateGenericValueOfInt(Ty, Int64_val(Int64), 1)))
[all...] |
| /external/llvm/bindings/ocaml/llvm/ |
| llvm_ocaml.c | 171 CAMLprim value llvm_classify_type(LLVMTypeRef Ty) {
172 return Val_int(LLVMGetTypeKind(Ty));
175 CAMLprim value llvm_type_is_sized(LLVMTypeRef Ty) {
176 return Val_bool(LLVMTypeIsSized(Ty));
180 CAMLprim LLVMContextRef llvm_type_context(LLVMTypeRef Ty) {
181 return LLVMGetTypeContext(Ty);
301 CAMLprim value llvm_struct_set_body(LLVMTypeRef Ty,
304 LLVMStructSetBody(Ty, (LLVMTypeRef *) ElementTypes,
310 CAMLprim value llvm_struct_name(LLVMTypeRef Ty)
313 const char *C = LLVMGetStructName(Ty);
[all...] |
| /external/llvm/lib/Bitcode/Reader/ |
| BitcodeReader.h | 79 Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
80 Value *getValueFwdRef(unsigned Idx, Type *Ty);
215 Value *getFnValueByID(unsigned ID, Type *Ty) {
216 if (Ty && Ty->isMetadataTy())
218 return ValueList.getValueFwdRef(ID, Ty);
251 Type *Ty, Value *&ResVal) {
254 ResVal = getFnValueByID(ValNo, Ty);
|
| /external/llvm/lib/Target/MBlaze/ |
| MBlazeTargetObjectFile.cpp | 72 Type *Ty = GV->getType()->getElementType();
73 return IsInSmallSection(TM.getTargetData()->getTypeAllocSize(Ty));
|
| /frameworks/compile/libbcc/bcinfo/BitReader_2_7/ |
| BitcodeReader.h | 84 Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
85 Value *getValueFwdRef(unsigned Idx, Type *Ty);
227 Value *getFnValueByID(unsigned ID, Type *Ty) {
228 if (Ty && Ty->isMetadataTy())
230 return ValueList.getValueFwdRef(ID, Ty);
263 Type *Ty, Value *&ResVal) {
266 ResVal = getFnValueByID(ValNo, Ty);
|
