Mercurial > projects > ldc
view ir/irstruct.h @ 1047:6bb04dbee21f
Some calling convention work for x86-64:
- Implement x86-64 extern(C), hopefully correctly.
- Tried to be a bit smarter about extern(D) while I was there.
Interestingly, this code seems to be generating more efficient code than
gcc and llvm-gcc in some edge cases, like returning a `{ [7 x i8] }` loaded from
a stack slot from an extern(C) function. (gcc generates 7 1-byte loads, while
this code generates a 4-byte, a 2-byte and a 1-byte load)
I also added some changes to make sure structs being returned from functions or
passed in as parameters are stored in memory where the rest of the backend seems
to expect them to be. These should be removed when support for first-class
aggregates improves.
author | Frits van Bommel <fvbommel wxs.nl> |
---|---|
date | Fri, 06 Mar 2009 16:00:47 +0100 |
parents | 1714836f2c0b |
children | 5ebe8224988b |
line wrap: on
line source
#ifndef LDC_IR_IRSTRUCT_H #define LDC_IR_IRSTRUCT_H #include "ir/ir.h" #include <vector> #include <map> struct IrInterface; void addZeros(std::vector<const llvm::Type*>& inits, size_t pos, size_t offset); void addZeros(std::vector<llvm::Constant*>& inits, size_t pos, size_t offset); void addZeros(std::vector<llvm::Value*>& inits, size_t pos, size_t offset); ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // represents a struct or class // it is used during codegen to hold all the vital info we need struct IrStruct : IrBase { ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// typedef std::vector<VarDeclaration*> VarDeclVector; typedef std::map<ClassDeclaration*, IrInterface*> InterfaceMap; typedef InterfaceMap::iterator InterfaceMapIter; typedef std::vector<IrInterface*> InterfaceVector; typedef InterfaceVector::iterator InterfaceVectorIter; // vector of LLVM types typedef std::vector<const llvm::Type*> TypeVector; ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// // Anon represents an anonymous struct union block inside an aggregate // during LLVM type construction. struct Anon { bool isunion; Anon* parent; TypeVector types; Anon(bool IsUnion, Anon* par) : isunion(IsUnion), parent(par) {} }; ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /// ctor IrStruct(AggregateDeclaration* agg); /// dtor virtual ~IrStruct(); ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /// push an anonymous struct/union void pushAnon(bool isunion); /// pops an anonymous struct/union void popAnon(); /// adds field void addVar(VarDeclaration* var); ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// /// build the aggr type const LLType* build(); /// put the aggr initializers in a vector void buildDefaultConstInit(std::vector<llvm::Constant*>& inits); /// ditto - but also builds the constant struct, for convenience LLConstant* buildDefaultConstInit(); ///////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////// // the D aggregate AggregateDeclaration* aggrdecl; // vector of VarDeclarations in this aggregate VarDeclVector varDecls; // vector of VarDeclarations that contribute to the default initializer VarDeclVector defVars; // true if the default initializer has been built bool defaultFound; // top element Anon* anon; // toplevel types in this aggr TypeVector types; // current index // always the same as types.size() size_t index; // aggregate D type Type* type; // class vtable type llvm::PATypeHolder vtblTy; llvm::PATypeHolder vtblInitTy; // initializer type opaque (type of global matches initializer, not formal type) llvm::PATypeHolder initOpaque; llvm::PATypeHolder classInfoOpaque; // map/vector of interfaces implemented InterfaceMap interfaceMap; InterfaceVector interfaceVec; // interface info array global LLGlobalVariable* interfaceInfos; // ... bool defined; bool constinited; // vtbl global and initializer LLGlobalVariable* vtbl; LLConstant* constVtbl; // static initializers global and constant LLGlobalVariable* init; LLConstant* constInit; // classinfo global and initializer constant LLGlobalVariable* classInfo; LLConstant* constClassInfo; bool classInfoDeclared; bool classInfoDefined; // vector of interfaces that should be put in ClassInfo.interfaces InterfaceVector classInfoInterfaces; // align(1) struct S { ... } bool packed; // composite type debug description llvm::DICompositeType diCompositeType; }; ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // represents interface implemented by a class struct IrInterface : IrBase { BaseClass* base; ClassDeclaration* decl; llvm::PATypeHolder vtblInitTy; LLConstant* vtblInit; LLGlobalVariable* vtbl; Array vtblDecls; // array of FuncDecls that make up the vtbl const LLStructType* infoTy; LLConstant* infoInit; LLConstant* info; size_t index; IrInterface(BaseClass* b); }; #endif