Mercurial > projects > ldc
view dmd/module.h @ 948:780530d1cad3
Revert templates to old behavior.
While emitting a template instantiation only once is good for compile times
and binary sizes, it doesn't work with linkonce linkage as inlined function
bodies could be discarded. Since we don't want to inhibit inlining, templates
are reverted to the previous behavior, where an instantiation is emitted for
each module using it.
In the future, a custom inlining pass may allow us to switch back to
common/weak linkage and reenable smart template instance emission.
author | Christian Kamm <kamm incasoftware de> |
---|---|
date | Sun, 08 Feb 2009 21:44:46 +0100 |
parents | 330f999ade44 |
children | 369996c08420 |
line wrap: on
line source
// Compiler implementation of the D programming language // Copyright (c) 1999-2008 by Digital Mars // All Rights Reserved // written by Walter Bright // http://www.digitalmars.com // License for redistribution is by either the Artistic License // in artistic.txt, or the GNU General Public License in gnu.txt. // See the included readme.txt for details. #ifndef DMD_MODULE_H #define DMD_MODULE_H #ifdef __DMC__ #pragma once #endif /* __DMC__ */ #include "root.h" #include "dsymbol.h" struct ModuleInfoDeclaration; struct ClassDeclaration; struct ModuleDeclaration; struct Macro; struct Escape; struct VarDeclaration; struct Library; // Back end #if IN_LLVM struct DValue; typedef DValue elem; #else #ifdef IN_GCC union tree_node; typedef union tree_node elem; #else struct elem; #endif #endif struct Package : ScopeDsymbol { Package(Identifier *ident); const char *kind(); static DsymbolTable *resolve(Array *packages, Dsymbol **pparent, Package **ppkg); Package *isPackage() { return this; } virtual void semantic(Scope *sc) { } }; struct Module : Package { static Module *rootModule; static DsymbolTable *modules; // symbol table of all modules static Array amodules; // array of all modules static Array deferred; // deferred Dsymbol's needing semantic() run on them static unsigned dprogress; // progress resolving the deferred list static void init(); static ClassDeclaration *moduleinfo; const char *arg; // original argument name ModuleDeclaration *md; // if !NULL, the contents of the ModuleDeclaration declaration File *srcfile; // input source file File *objfile; // output object file File *docfile; // output doc file File *hdrfile; // output hdr file unsigned errors; // if any errors in file unsigned numlines; // number of lines in source file int isHtml; // if it is an HTML file int isDocFile; // if it is a documentation input file, not D source int needmoduleinfo; #ifdef IN_GCC int strictlyneedmoduleinfo; #endif int insearch; Identifier *searchCacheIdent; Dsymbol *searchCacheSymbol; // cached value of search int searchCacheFlags; // cached flags int semanticstarted; // has semantic() been started? int semanticdone; // has semantic() been done? int root; // != 0 if this is a 'root' module, // i.e. a module that will be taken all the // way to an object file Module *importedFrom; // module from command line we're imported from, // i.e. a module that will be taken all the // way to an object file Array *decldefs; // top level declarations for this Module Array aimports; // all imported modules ModuleInfoDeclaration *vmoduleinfo; unsigned debuglevel; // debug level Array *debugids; // debug identifiers Array *debugidsNot; // forward referenced debug identifiers unsigned versionlevel; // version level Array *versionids; // version identifiers Array *versionidsNot; // forward referenced version identifiers Macro *macrotable; // document comment macros struct Escape *escapetable; // document comment escapes int doDocComment; // enable generating doc comments for this module int doHdrGen; // enable generating header file for this module Module(char *arg, Identifier *ident, int doDocComment, int doHdrGen); ~Module(); static Module *load(Loc loc, Array *packages, Identifier *ident); void toCBuffer(OutBuffer *buf, HdrGenState *hgs); const char *kind(); void read(Loc loc); // read file #if IN_GCC void parse(bool dump_source = false); // syntactic parse #else void parse(); // syntactic parse #endif void semantic(Scope* unused_sc = NULL); // semantic analysis void semantic2(Scope* unused_sc = NULL); // pass 2 semantic analysis void semantic3(Scope* unused_sc = NULL); // pass 3 semantic analysis void inlineScan(); // scan for functions to inline #ifdef _DH void genhdrfile(); // generate D import file #endif void genobjfile(int multiobj); // void gensymfile(); void gendocfile(); int needModuleInfo(); Dsymbol *search(Loc loc, Identifier *ident, int flags); void deleteObjFile(); void addDeferredSemantic(Dsymbol *s); void runDeferredSemantic(); int imports(Module *m); // Back end int doppelganger; // sub-module Symbol *cov; // private uint[] __coverage; unsigned *covb; // bit array of valid code line numbers Symbol *sictor; // module order independent constructor Symbol *sctor; // module constructor Symbol *sdtor; // module destructor Symbol *stest; // module unit test Symbol *sfilename; // symbol for filename Symbol *massert; // module assert function Symbol *toModuleAssert(); // get module assert function Symbol *marray; // module array bounds function Symbol *toModuleArray(); // get module array bounds function static Symbol *gencritsec(); elem *toEfilename(); elem *toEmodulename(); Symbol *toSymbol(); void genmoduleinfo(); // LDC void buildTargetFiles(); File* buildFilePath(char* forcename, char* path, char* ext); Module *isModule() { return this; } bool llvmForceLogging; // array ops emitted in this module already StringTable arrayfuncs; }; struct ModuleDeclaration { Identifier *id; Array *packages; // array of Identifier's representing packages ModuleDeclaration(Array *packages, Identifier *id); char *toChars(); }; #endif /* DMD_MODULE_H */