Mercurial > projects > ldc
view ir/irfunction.h @ 1499:df11cdec45a2
Another shot at fixing the issues with (constant) struct literals and their addresses. See DMD2682, #218, #324.
The idea is to separate the notion of const from 'this variable can always be
replaced with its initializer' in the frontend. To do that, I introduced
Declaration::isSameAsInitializer, which is overridden in VarDeclaration to
return false for constants that have a struct literal initializer.
So
{{{
const S s = S(5);
void foo() { auto ps = &s; }
// is no longer replaced by
void foo() { auto ps = &(S(5)); }
}}}
To make taking the address of a struct constant with a struct-initializer
outside of function scope possible, I made sure that AddrExp::optimize doesn't
try to run the argument's optimization with WANTinterpret - that'd again
replace the constant with a struct literal temporary.
author | Christian Kamm <kamm incasoftware de> |
---|---|
date | Sun, 14 Jun 2009 19:49:58 +0200 |
parents | 3f5ea912149d |
children | e1e93343fc11 |
line wrap: on
line source
#ifndef LDC_IR_IRFUNCTION_H #define LDC_IR_IRFUNCTION_H #include "gen/llvm.h" #include "ir/ir.h" #include "ir/irlandingpad.h" #include <vector> #include <stack> #include <map> struct Statement; struct EnclosingHandler; // scope statements that can be target of jumps // includes loops, switch, case, labels struct IRTargetScope { // generating statement Statement* s; // the try of a TryFinally that encloses the loop EnclosingHandler* enclosinghandler; llvm::BasicBlock* breakTarget; llvm::BasicBlock* continueTarget; IRTargetScope(); IRTargetScope(Statement* s, EnclosingHandler* enclosinghandler, llvm::BasicBlock* continueTarget, llvm::BasicBlock* breakTarget); }; // represents a function struct IrFunction : IrBase { llvm::Function* func; llvm::Instruction* allocapoint; FuncDeclaration* decl; TypeFunction* type; bool queued; bool defined; llvm::Value* retArg; // return in ptr arg llvm::Value* thisArg; // class/struct 'this' arg llvm::Value* nestArg; // nested function 'this' arg llvm::Value* nestedVar; // nested var alloca const llvm::StructType* frameType; // type of nested context (not for -nested-ctx=array) // number of enclosing functions with variables accessed by nested functions // (-1 if neither this function nor any enclosing ones access variables from enclosing functions) int depth; llvm::Value* _arguments; llvm::Value* _argptr; llvm::DISubprogram diSubprogram; // pushes a unique label scope of the given name void pushUniqueLabelScope(const char* name); // pops a label scope void popLabelScope(); // gets the string under which the label's BB // is stored in the labelToBB map. // essentially prefixes ident by the strings in labelScopes std::string getScopedLabelName(const char* ident); // label to basic block lookup typedef std::map<std::string, llvm::BasicBlock*> LabelToBBMap; LabelToBBMap labelToBB; // landing pads for try statements IRLandingPad landingPadInfo; llvm::BasicBlock* landingPad; // loop blocks typedef std::vector<IRTargetScope> TargetScopeVec; TargetScopeVec targetScopes; // constructor IrFunction(FuncDeclaration* fd); // annotations void setNeverInline(); void setAlwaysInline(); private: // prefix for labels and gotos // used for allowing labels to be emitted twice std::vector<std::string> labelScopes; // next unique id stack std::stack<int> nextUnique; }; #endif