|
145
|
1 /* imports.cc -- Build imported modules/declarations.
|
|
|
2 Copyright (C) 2014-2020 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 GCC is free software; you can redistribute it and/or modify
|
|
|
5 it under the terms of the GNU General Public License as published by
|
|
|
6 the Free Software Foundation; either version 3, or (at your option)
|
|
|
7 any later version.
|
|
|
8
|
|
|
9 GCC is distributed in the hope that it will be useful,
|
|
|
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
12 GNU General Public License for more details.
|
|
|
13
|
|
|
14 You should have received a copy of the GNU General Public License
|
|
|
15 along with GCC; see the file COPYING3. If not see
|
|
|
16 <http://www.gnu.org/licenses/>. */
|
|
|
17
|
|
|
18 #include "config.h"
|
|
|
19 #include "system.h"
|
|
|
20 #include "coretypes.h"
|
|
|
21
|
|
|
22 #include "dmd/aggregate.h"
|
|
|
23 #include "dmd/declaration.h"
|
|
|
24 #include "dmd/enum.h"
|
|
|
25 #include "dmd/identifier.h"
|
|
|
26 #include "dmd/import.h"
|
|
|
27 #include "dmd/module.h"
|
|
|
28
|
|
|
29 #include "tree.h"
|
|
|
30 #include "stringpool.h"
|
|
|
31
|
|
|
32 #include "d-tree.h"
|
|
|
33
|
|
|
34
|
|
|
35 /* Implements the visitor interface to build debug trees for all
|
|
|
36 module and import declarations, where ISYM holds the cached
|
|
|
37 back-end representation to be returned. */
|
|
|
38 class ImportVisitor : public Visitor
|
|
|
39 {
|
|
|
40 using Visitor::visit;
|
|
|
41
|
|
|
42 /* Build the declaration DECL as an imported symbol. */
|
|
|
43 tree make_import (tree decl)
|
|
|
44 {
|
|
|
45 gcc_assert (decl != NULL_TREE);
|
|
|
46
|
|
|
47 tree import = build_decl (input_location, IMPORTED_DECL,
|
|
|
48 DECL_NAME (decl), void_type_node);
|
|
|
49 IMPORTED_DECL_ASSOCIATED_DECL (import) = decl;
|
|
|
50 d_keep (import);
|
|
|
51
|
|
|
52 return import;
|
|
|
53 }
|
|
|
54
|
|
|
55 public:
|
|
|
56 ImportVisitor (void)
|
|
|
57 {
|
|
|
58 }
|
|
|
59
|
|
|
60 /* This should be overridden by each symbol class. */
|
|
|
61 void visit (Dsymbol *)
|
|
|
62 {
|
|
|
63 gcc_unreachable ();
|
|
|
64 }
|
|
|
65
|
|
|
66 /* Build the module decl for M, this is considered toplevel, regardless
|
|
|
67 of whether there are any parent packages in the module system. */
|
|
|
68 void visit (Module *m)
|
|
|
69 {
|
|
|
70 Loc loc = (m->md != NULL) ? m->md->loc
|
|
|
71 : Loc (m->srcfile->toChars (), 1, 0);
|
|
|
72
|
|
|
73 m->isym = build_decl (make_location_t (loc), NAMESPACE_DECL,
|
|
|
74 get_identifier (m->toPrettyChars ()),
|
|
|
75 void_type_node);
|
|
|
76 d_keep (m->isym);
|
|
|
77
|
|
|
78 if (!m->isRoot ())
|
|
|
79 DECL_EXTERNAL (m->isym) = 1;
|
|
|
80
|
|
|
81 TREE_PUBLIC (m->isym) = 1;
|
|
|
82 DECL_CONTEXT (m->isym) = NULL_TREE;
|
|
|
83 }
|
|
|
84
|
|
|
85 /* Build an import of another module symbol. */
|
|
|
86
|
|
|
87 void visit (Import *m)
|
|
|
88 {
|
|
|
89 tree module = build_import_decl (m->mod);
|
|
|
90 m->isym = this->make_import (module);
|
|
|
91 }
|
|
|
92
|
|
|
93 /* Build an import for any kind of user defined type.
|
|
|
94 Use the TYPE_DECL associated with the type symbol. */
|
|
|
95 void visit (EnumDeclaration *d)
|
|
|
96 {
|
|
|
97 tree type = build_ctype (d->type);
|
|
|
98 /* Not all kinds of D enums create a TYPE_DECL. */
|
|
|
99 if (TREE_CODE (type) == ENUMERAL_TYPE)
|
|
|
100 d->isym = this->make_import (TYPE_STUB_DECL (type));
|
|
|
101 }
|
|
|
102
|
|
|
103 void visit (AggregateDeclaration *d)
|
|
|
104 {
|
|
|
105 tree type = build_ctype (d->type);
|
|
|
106 d->isym = this->make_import (TYPE_STUB_DECL (type));
|
|
|
107 }
|
|
|
108
|
|
|
109 void visit (ClassDeclaration *d)
|
|
|
110 {
|
|
|
111 /* Want the RECORD_TYPE, not POINTER_TYPE. */
|
|
|
112 tree type = TREE_TYPE (build_ctype (d->type));
|
|
|
113 d->isym = this->make_import (TYPE_STUB_DECL (type));
|
|
|
114 }
|
|
|
115
|
|
|
116 /* For now, ignore importing other kinds of dsymbols. */
|
|
|
117 void visit (ScopeDsymbol *)
|
|
|
118 {
|
|
|
119 }
|
|
|
120
|
|
|
121 /* Alias symbols aren't imported, but their targets are. */
|
|
|
122 void visit (AliasDeclaration *d)
|
|
|
123 {
|
|
|
124 Dsymbol *dsym = d->toAlias ();
|
|
|
125
|
|
|
126 if (dsym == d)
|
|
|
127 {
|
|
|
128 Type *type = d->getType ();
|
|
|
129
|
|
|
130 /* Type imports should really be part of their own visit method. */
|
|
|
131 if (type != NULL)
|
|
|
132 {
|
|
|
133 if (type->ty == Tenum)
|
|
|
134 dsym = ((TypeEnum *) type)->sym;
|
|
|
135 else if (type->ty == Tstruct)
|
|
|
136 dsym = ((TypeStruct *) type)->sym;
|
|
|
137 else if (type->ty == Tclass)
|
|
|
138 dsym = ((TypeClass *) type)->sym;
|
|
|
139 }
|
|
|
140 }
|
|
|
141
|
|
|
142 /* This symbol is really an alias for another, visit the other. */
|
|
|
143 if (dsym != d)
|
|
|
144 {
|
|
|
145 dsym->accept (this);
|
|
|
146 d->isym = dsym->isym;
|
|
|
147 }
|
|
|
148 }
|
|
|
149
|
|
|
150 /* Visit the underlying alias symbol of overloadable aliases. */
|
|
|
151 void visit (OverDeclaration *d)
|
|
|
152 {
|
|
|
153 if (d->aliassym != NULL)
|
|
|
154 {
|
|
|
155 d->aliassym->accept (this);
|
|
|
156 d->isym = d->aliassym->isym;
|
|
|
157 }
|
|
|
158 }
|
|
|
159
|
|
|
160 /* Function aliases are the same as alias symbols. */
|
|
|
161 void visit (FuncAliasDeclaration *d)
|
|
|
162 {
|
|
|
163 FuncDeclaration *fd = d->toAliasFunc ();
|
|
|
164
|
|
|
165 if (fd != NULL)
|
|
|
166 {
|
|
|
167 fd->accept (this);
|
|
|
168 d->isym = fd->isym;
|
|
|
169 }
|
|
|
170 }
|
|
|
171
|
|
|
172 /* Skip over importing templates and tuples. */
|
|
|
173 void visit (TemplateDeclaration *)
|
|
|
174 {
|
|
|
175 }
|
|
|
176
|
|
|
177 void visit (TupleDeclaration *)
|
|
|
178 {
|
|
|
179 }
|
|
|
180
|
|
|
181 /* Import any other kind of declaration. If the class does not implement
|
|
|
182 symbol generation routines, the compiler will throw an error. */
|
|
|
183 void visit (Declaration *d)
|
|
|
184 {
|
|
|
185 d->isym = this->make_import (get_symbol_decl (d));
|
|
|
186 }
|
|
|
187 };
|
|
|
188
|
|
|
189
|
|
|
190 /* Build a declaration for the symbol D that can be used for the
|
|
|
191 debug_hook imported_module_or_decl. */
|
|
|
192 tree
|
|
|
193 build_import_decl (Dsymbol *d)
|
|
|
194 {
|
|
|
195 if (!d->isym)
|
|
|
196 {
|
|
|
197 location_t saved_location = input_location;
|
|
|
198 ImportVisitor v;
|
|
|
199
|
|
|
200 input_location = make_location_t (d->loc);
|
|
|
201 d->accept (&v);
|
|
|
202 input_location = saved_location;
|
|
|
203 }
|
|
|
204
|
|
|
205 /* Not all visitors set 'isym'. */
|
|
|
206 return d->isym ? d->isym : NULL_TREE;
|
|
|
207 }
|
|
|
208
|
