search for: argtypes

...igned i = 0, e = I->second.size(); i != e; ++i) { + OS << " case Intrinsic::" << Ints[I->second[i]].EnumName << ":\t\t// " + << Ints[I->second[i]].Name << "\n"; + } + + const std::vector<Record*> &ArgTypes = I->first; + OS << " return M->getOrInsertFunction(Intrinsic::getName(ID), "; + for (unsigned j = 0; j != ArgTypes.size(); ++j) { + EmitTypeGenerate(OS, ArgTypes[j]); + OS << ", "; + } + OS << "NULL);\n"; + } + OS &lt...

On Mon, 5 Feb 2007, Dan Gohman wrote: > LLVM knows what all the types of the intrinsic functions are; I thought, > why are users (including llvm-gcc...) required to duplicate all this > information in order to use them? I mean in order to call > getOrInsertFunction to get declarations for them. That is an excellent question! :) In the bad old days, we used to allow intrinsics

...igned i = 0, e = I->second.size(); i != e; ++i) { + OS << " case Intrinsic::" << Ints[I->second[i]].EnumName << ":\t\t// " + << Ints[I->second[i]].Name << "\n"; + } + + const std::vector<Record*> &ArgTypes = I->first; + OS << " return M->getOrInsertFunction(Intrinsic::getName(id), "; + for (unsigned j = 0; j != ArgTypes.size(); ++j) { + EmitTypeGenerate(OS, ArgTypes[j]); + OS << ", "; + } + OS << "NULL);\n"; + } + OS &lt...

In IntrinsicEmitter::EmitTypeGenerate, called from IntrinsicEmitter::EmitGenerator, here for (unsigned j = 0; j != N; ++j) { OS << " ArgTys.push_back("; EmitTypeGenerate(OS, ParamTys[j], ArgNo); OS << ");\n"; } I'm hitting this assertion: if (ArgType->isSubClassOf("LLVMMatchType")) { unsigned Number =

...; > else { > - *this = std::move(*O); > + *this = std::move(*O.getPointer()); > O.reset(); > } > return *this; > } > > - /// Create a new object by constructing it in place with the given > arguments. > - template <typename... ArgTypes> void emplace(ArgTypes &&... Args) { > - reset(); > - hasVal = true; > - new (storage.buffer) T(std::forward<ArgTypes>(Args)...); > - } > - > - static inline Optional create(const T *y) { > - return y ? Optional(*y) : Optional(); > - } > -...

That's a bug. I'm working on a fix.... On Apr 15, 2009, at 10:16 AM, Villmow, Micah wrote: > In IntrinsicEmitter::EmitTypeGenerate, called from > IntrinsicEmitter::EmitGenerator, here > for (unsigned j = 0; j != N; ++j) { > OS << " ArgTys.push_back("; > EmitTypeGenerate(OS, ParamTys[j], ArgNo); > OS << ");\n"; > }

...= std::move(*O); >> + *this = std::move(*O.getPointer()); >> O.reset(); >> } >> return *this; >> } >> >> - /// Create a new object by constructing it in place with the given >> arguments. >> - template <typename... ArgTypes> void emplace(ArgTypes &&... Args) { >> - reset(); >> - hasVal = true; >> - new (storage.buffer) T(std::forward<ArgTypes>(Args)...); >> - } >> - >> - static inline Optional create(const T *y) { >> - return y ? Optional(*y) : O...

...0x00000000005285b3 main + 7251 13 libc.so.6 0x00007f039618076d __libc_start_main + 237 14 opt 0x0000000000521f91 Stack dump: 0. Program arguments: opt -load ../../../Release+Asserts/lib/Blocks.so -blocks Aborted (core dumped) ***The code is > std::vector<Type*> ArgTypes; > ValueToValueMapTy VMap; >FunctionType *FTy = FunctionType::get(F.getFunctionType()->getReturnType(), ArgTypes, F.getFunctionType()->isVarArg()); >Function *NewF = Function::Create(FTy, F.getLinkage(), F.getName()); > SmallVector<ReturnInst*, 8...

..., 2010, at 11:30 AM, F van der Meeren wrote: > > > Any ideas on what I am doing wrong here ? > Why not just use something like: const Type *ArgPtr = Type::getInt8PtrTy(Context); const Type *IntPtr = getTargetData().getIntPtrType(Context); and then: const Type *ArgTypes[3] = {ArgPtr, ArgPtr, IntPtr }; Intrinsic::getDeclaration(TheModule, Intrinsic::memcpy, ArgTypes, 3) to get the type of memcpy? Trying to declare it that way is likely confusing to the system. -eric

...= std::move(*O.getPointer()); > >> O.reset(); > >> } > >> return *this; > >> } > >> > >> - /// Create a new object by constructing it in place with the given > >> arguments. > >> - template <typename... ArgTypes> void emplace(ArgTypes &&... Args) { > >> - reset(); > >> - hasVal = true; > >> - new (storage.buffer) T(std::forward<ArgTypes>(Args)...); > >> - } > >> - > >> - static inline Optional create(const T *y) { > >&g...

Hi, I have a sample of size 100 from a function in interval [0,1] which can be assumed to come from a scalar-valued stationary Gaussian process. There are about 500 observation points in the interval. I need an effective and fast way to simulate from the Gaussian process conditioned on the available data. I can of course estimate the mean and 500x500 covariance matrix from data. I have searched

I have created the function prototype with the following code: const uintmax_t methodNameSize = 1024; const char methodNameTemplate[] = "llvm.memcpy.p0i%llu.p0i%llu.i%llu"; char methodName[methodNameSize]; // Create the methodName. memset(methodName, 0, methodNameSize); sprintf(methodName, methodNameTemplate, dstSize, srcSize, lengthSize); // Search for the

...her - maybe when deleting SDNode the destructor frees the char *. // This seems to be so because of this method doing creation of the SDNode, which is used also by getTargetExternalSymbol(): template <typename SDNodeT, typename... ArgTypes> SDNodeT *newSDNode(ArgTypes &&... Args) { return new (NodeAllocator.template Allocate<SDNodeT>()) SDNodeT(std::forward<ArgTypes>(Args)...); } */ char *exprStrChar = (char *)malloc(2048);...

...0007f039618076d __libc_start_main + 237 > 14 opt 0x0000000000521f91 > Stack dump: > 0. Program arguments: opt -load ../../../Release+Asserts/lib/Blocks.so > -blocks > Aborted (core dumped) > > > > ***The code is > > > > std::vector<Type*> ArgTypes; > > > ValueToValueMapTy VMap; > > >FunctionType *FTy = > FunctionType::get(F.getFunctionType()->getReturnType(), > ArgTypes, F.getFunctionType()->isVarArg()); > > >Function *NewF = Function::Create(FTy, F.getLinkage(), F.getName());...

...rtion failed: (isa<X>(Val) && "cast<Ty>() argument of incompatible type!"), function cast, file /usr/local/include/llvm/Support/Casting.h, line 202. Code snippets... id testfunc(id a, id b) { ... } ... FunctionType *fn_type = FunctionType::get(id_type, argtypes, false); Value *fn = ConstantExpr::getIntToPtr(ConstantInt::get(int64_type, reinterpret_cast<int64_t>(testfunc)), fn_type); return builder.CreateCall2(fn, arg0val, arg1val); // <-- assertion fails here What am I doing wrong? I can paste more code if needed. thanks, Rob

...version] gs->gsbase.subcode &= ~GF_PREDICT_TAKEN; ^ ~~~~~~~~~~~~~~~~~ /sw/src/fink.build/dragonegg-gcc45-3.0-1/dragonegg-3.0/src/Convert.cpp:429:64: error: too many arguments to function call, expected 3, have 4 ArgTypes, 3), Ops); ^ /sw/opt/llvm-3.0/include/llvm/Intrinsics.h:71:3: note: 'getDeclaration' declared here Function *getDeclaration(Module *M, ID id, ^ /sw/src/fink.build/dragonegg-gcc45-3.0-1/dragonegg-3.0/src/Convert.cpp:1674:58:...

...t;gsbase.subcode &= ~GF_PREDICT_TAKEN; > ^ ~~~~~~~~~~~~~~~~~ > /sw/src/fink.build/dragonegg-gcc45-3.0-1/dragonegg-3.0/src/Convert.cpp:429:64: > error: too many arguments to function call, expected 3, have 4 > ArgTypes, 3), Ops); > ^ > /sw/opt/llvm-3.0/include/llvm/Intrinsics.h:71:3: note: 'getDeclaration' > declared here > Function *getDeclaration(Module *M, ID id, > ^ > /sw/src/fink.build/dragonegg-gcc45-3.0-1/dragonegg-3....

Oops. That was premature. I think your original question was on the right track. TableGen distinguishes between known and "overloaded" types (like "llvm_anyfloat_ty" in your example). The overloaded types are numbered separately, and the argument to LLVMMatchType is an index into these overloaded types, ignoring the known types. So, in your case, the first

...; #include "llvm/ADT/DenseMap.h" #include "llvm/Transforms/Utils/Cloning.h" using namespace std; using namespace llvm; static Function *cloneFunctionInfo(const Function *F, ValueToValueMapTy& ValueMap) { vector<const Type*> ArgTypes; // The user might be deleting arguments to the function by specifying them in // the ValueMap. If so, we need to not add the arguments to the arg ty vector // for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) if (ValueMap.cou...

I have this intrinsic definition for llvm. def int_opencl_math_fdistance_fast : Intrinsic<[llvm_float_ty], [llvm_anyfloat_ty, LLVMMatchType<0>]>; Can someone explain what LLVMMatchType does and how to specify it to match the first argument and not the return value? I've tried LLVMMatchType<1> but it fails in IntrinsicEmitter.cpp