search for: containedtys

...> --- include/llvm/Type.h 19 Nov 2004 16:39:04 -0000 1.67 > +++ include/llvm/Type.h 13 Dec 2004 13:11:57 -0000 > @@ -246,7 +246,8 @@ > > /// getNumContainedTypes - Return the number of types in the derived type. > /// > - unsigned getNumContainedTypes() const { return ContainedTys.size(); } > + typedef std::vector<PATypeHandle>::size_type size_type; > + size_type getNumContainedTypes() const { return ContainedTys.size(); } > > //===--------------------------------------------------------------------===// > // Static members exported by the Type...

Hi, here are some minor patches that for various reasons I've not submitted yet - I'm just trying to clear my list of differences before christmas... First of all the clear.patch file contains a patch that enables the JIT to drop all global mappings. I need this because when I have N threads I compile N different versions of my functions using different memory areas for global

..._impl = {<std::allocator<llvm::AbstractTypeUser*>> = {<__gnu_cxx::new_allocator<llvm::AbstractTypeUser*>> = {<No data fields>}, <No data fields>}, _M_start = 0x921f726, _M_finish = 0x921a090, _M_end_of_storage = 0x921e898}}, <No data fields>}, NumContainedTys = 153198753, ContainedTys = 0x89f3aac} Thanks for the help. Regards Rajesh

...-- it seems the LLVM type factories are creating objects in their 'get' method which are never deleted. This is unacceptable because these warnings make it very hard to track if any other memory is leaking from the application. I tried deleting these types but ran into problems with the ContainedTys referencing types which have already been deleted causing the application to crash when calling the destructor. It seems that to delete the types properly on program exit the reference counting has to be enabled also for types which are not abstract -- is this possible? m.

...could be a more general way to support packed type. The member fucntion SequentialType::getElementType() returns the type of the packed elements: File: include/llvm/Type.h <code> class SequentialType : public CompositeType { public: inline const Type *getElementType() const { return ContainedTys[0]; } }; class PackedType : public SequentialType { public: inline unsigned getNumElements() const { return NumElements; } }; </code> If SDOperand can return a "const Type *", the element type of the packed type can be obtained, and only one enum value 'packed'...

...tants. + if (V->getType() == Type::getInt32Ty(V->getContext())) Please use V->getType()->isInteger(32) which is probably new since you started your patch. +UnionType::UnionType(LLVMContext &C, const std::vector<const Type*> &Types) + : CompositeType(C, UnionTyID) { + ContainedTys = reinterpret_cast<PATypeHandle*>(this + 1); + NumContainedTys = Types.size(); + bool isAbstract = false; + for (unsigned i = 0; i < Types.size(); ++i) { No need to evaluate Types.size() every time through the loop. +bool LLParser::ParseUnionType(PATypeHolder &Result) { ... + if...

This patch adds a UnionType to DerivedTypes.h. It also adds code to the bitcode reader / writer and the assembly parser for the new type, as well as a tiny .ll test file in test/Assembler. It does not contain any code related to code generation or type layout - I wanted to see if this much was acceptable before I proceeded any further. Unlike my previous patch, in which the Union type was

On Mon, 25 Jul 2005, Tzu-Chien Chiu wrote: > But please allow me to explain the hardware in detail. Hope there is > more elegant way to solve it. Sounds good! > The hardware is a "stream processor". That is, It processes samples > one by one. Each sample is associated with several 128-bit > four-element vector registers, namely: > > * input registers - the

On Fri, 1 Sep 2006, Michael McCracken wrote: > Here's what works now, and I have a separate test case for each of these: > > statement functions > intrinsic functions (print, cos, etc) > loops, goto statments > scalarized array operations > function calls with *no arguments* > simple common blocks Great! > Function calls with more than one argument don't work.

...Int32Ty(V->getContext())) > > Please use V->getType()->isInteger(32) which is probably new since you > started your patch. > > > +UnionType::UnionType(LLVMContext &C, const std::vector<const Type*> > &Types) > + : CompositeType(C, UnionTyID) { > + ContainedTys = reinterpret_cast<PATypeHandle*>(this + 1); > + NumContainedTys = Types.size(); > + bool isAbstract = false; > + for (unsigned i = 0; i < Types.size(); ++i) { > > No need to evaluate Types.size() every time through the loop. > > > +bool LLParser::ParseUnionType(...

The NIST F77 test suite doesn't seem to be compatible with gfortran at all, so I had to work from my own sample codes, and generate test cases from them. Here's what works now, and I have a separate test case for each of these: statement functions intrinsic functions (print, cos, etc) loops, goto statments scalarized array operations function calls with *no arguments* simple common

Thanks, I think it can solve my problem. But please allow me to explain the hardware in detail. Hope there is more elegant way to solve it. The hardware is a "stream processor". That is, It processes samples one by one. Each sample is associated with several 128-bit four-element vector registers, namely: * input registers - the attributes of the sample, the values of the registers

Hi all, We're hitting some walls here when generating the correct structure layout for specific C++ ABI requirements, and I was wondering how much StructLayout could help. For instance, the ABI has some complicated rules on the size of derived classes (http://www.codesourcery.com/public/cxx-abi/abi.html#class-types) and LLVM struct type cannot reflect that in full. Example: // CHECK: