|
111
|
1 // go.cc -- Go frontend main file for gcc.
|
|
|
2
|
|
|
3 // Copyright 2009 The Go Authors. All rights reserved.
|
|
|
4 // Use of this source code is governed by a BSD-style
|
|
|
5 // license that can be found in the LICENSE file.
|
|
|
6
|
|
|
7 #include "go-system.h"
|
|
|
8
|
|
|
9 #include "go-c.h"
|
|
|
10 #include "go-diagnostics.h"
|
|
|
11
|
|
|
12 #include "lex.h"
|
|
|
13 #include "parse.h"
|
|
|
14 #include "backend.h"
|
|
|
15 #include "gogo.h"
|
|
|
16
|
|
|
17 // The data structures we build to represent the file.
|
|
|
18 static Gogo* gogo;
|
|
|
19
|
|
|
20 // Create the main IR data structure.
|
|
|
21
|
|
|
22 GO_EXTERN_C
|
|
|
23 void
|
|
|
24 go_create_gogo(const struct go_create_gogo_args* args)
|
|
|
25 {
|
|
|
26 go_assert(::gogo == NULL);
|
|
|
27 ::gogo = new Gogo(args->backend, args->linemap, args->int_type_size,
|
|
|
28 args->pointer_size);
|
|
|
29
|
|
|
30 if (args->pkgpath != NULL)
|
|
|
31 ::gogo->set_pkgpath(args->pkgpath);
|
|
|
32 else if (args->prefix != NULL)
|
|
|
33 ::gogo->set_prefix(args->prefix);
|
|
|
34
|
|
|
35 if (args->relative_import_path != NULL)
|
|
|
36 ::gogo->set_relative_import_path(args->relative_import_path);
|
|
|
37 ::gogo->set_check_divide_by_zero(args->check_divide_by_zero);
|
|
|
38 ::gogo->set_check_divide_overflow(args->check_divide_overflow);
|
|
|
39 if (args->compiling_runtime)
|
|
|
40 ::gogo->set_compiling_runtime(args->compiling_runtime);
|
|
|
41 if (args->c_header != NULL)
|
|
|
42 ::gogo->set_c_header(args->c_header);
|
|
|
43 ::gogo->set_debug_escape_level(args->debug_escape_level);
|
|
131
|
44 if (args->debug_escape_hash != NULL)
|
|
|
45 ::gogo->set_debug_escape_hash(args->debug_escape_hash);
|
|
|
46 ::gogo->set_nil_check_size_threshold(args->nil_check_size_threshold);
|
|
111
|
47 }
|
|
|
48
|
|
|
49 // Parse the input files.
|
|
|
50
|
|
|
51 GO_EXTERN_C
|
|
|
52 void
|
|
|
53 go_parse_input_files(const char** filenames, unsigned int filename_count,
|
|
|
54 bool only_check_syntax, bool)
|
|
|
55 {
|
|
|
56 go_assert(filename_count > 0);
|
|
|
57
|
|
|
58 Lex::Linknames all_linknames;
|
|
|
59 for (unsigned int i = 0; i < filename_count; ++i)
|
|
|
60 {
|
|
|
61 if (i > 0)
|
|
|
62 ::gogo->clear_file_scope();
|
|
|
63
|
|
|
64 const char* filename = filenames[i];
|
|
|
65 FILE* file;
|
|
|
66 if (strcmp(filename, "-") == 0)
|
|
|
67 file = stdin;
|
|
|
68 else
|
|
|
69 {
|
|
|
70 file = fopen(filename, "r");
|
|
|
71 if (file == NULL)
|
|
|
72 go_fatal_error(Linemap::unknown_location(),
|
|
|
73 "cannot open %s: %m", filename);
|
|
|
74 }
|
|
|
75
|
|
|
76 Lex lexer(filename, file, ::gogo->linemap());
|
|
|
77
|
|
|
78 Parse parse(&lexer, ::gogo);
|
|
|
79 parse.program();
|
|
|
80
|
|
|
81 if (strcmp(filename, "-") != 0)
|
|
|
82 fclose(file);
|
|
|
83
|
|
|
84 Lex::Linknames* linknames = lexer.get_and_clear_linknames();
|
|
|
85 if (linknames != NULL)
|
|
|
86 {
|
|
|
87 if (!::gogo->current_file_imported_unsafe())
|
|
|
88 {
|
|
|
89 for (Lex::Linknames::const_iterator p = linknames->begin();
|
|
|
90 p != linknames->end();
|
|
|
91 ++p)
|
|
|
92 go_error_at(p->second.loc,
|
|
|
93 ("//go:linkname only allowed in Go files that "
|
|
|
94 "import \"unsafe\""));
|
|
|
95 }
|
|
|
96 all_linknames.insert(linknames->begin(), linknames->end());
|
|
|
97 }
|
|
|
98 }
|
|
|
99
|
|
|
100 ::gogo->linemap()->stop();
|
|
|
101
|
|
|
102 ::gogo->clear_file_scope();
|
|
|
103
|
|
|
104 // If the global predeclared names are referenced but not defined,
|
|
|
105 // define them now.
|
|
|
106 ::gogo->define_global_names();
|
|
|
107
|
|
|
108 // Apply any go:linkname directives.
|
|
|
109 for (Lex::Linknames::const_iterator p = all_linknames.begin();
|
|
|
110 p != all_linknames.end();
|
|
|
111 ++p)
|
|
|
112 ::gogo->add_linkname(p->first, p->second.is_exported, p->second.ext_name,
|
|
|
113 p->second.loc);
|
|
|
114
|
|
|
115 // Finalize method lists and build stub methods for named types.
|
|
|
116 ::gogo->finalize_methods();
|
|
|
117
|
|
|
118 // Check that functions have a terminating statement.
|
|
|
119 ::gogo->check_return_statements();
|
|
|
120
|
|
|
121 // Now that we have seen all the names, lower the parse tree into a
|
|
|
122 // form which is easier to use.
|
|
|
123 ::gogo->lower_parse_tree();
|
|
|
124
|
|
|
125 // Create function descriptors as needed.
|
|
|
126 ::gogo->create_function_descriptors();
|
|
|
127
|
|
|
128 // Now that we have seen all the names, verify that types are
|
|
|
129 // correct.
|
|
|
130 ::gogo->verify_types();
|
|
|
131
|
|
|
132 // Work out types of unspecified constants and variables.
|
|
|
133 ::gogo->determine_types();
|
|
|
134
|
|
|
135 // Check types and issue errors as appropriate.
|
|
|
136 ::gogo->check_types();
|
|
|
137
|
|
|
138 if (only_check_syntax)
|
|
|
139 return;
|
|
|
140
|
|
|
141 ::gogo->analyze_escape();
|
|
|
142
|
|
|
143 // Export global identifiers as appropriate.
|
|
|
144 ::gogo->do_exports();
|
|
|
145
|
|
131
|
146 // Use temporary variables to force order of evaluation.
|
|
|
147 ::gogo->order_evaluations();
|
|
|
148
|
|
111
|
149 // Turn short-cut operators (&&, ||) into explicit if statements.
|
|
|
150 ::gogo->remove_shortcuts();
|
|
|
151
|
|
|
152 // Convert named types to backend representation.
|
|
|
153 ::gogo->convert_named_types();
|
|
|
154
|
|
|
155 // Build thunks for functions which call recover.
|
|
|
156 ::gogo->build_recover_thunks();
|
|
|
157
|
|
|
158 // Convert complicated go and defer statements into simpler ones.
|
|
|
159 ::gogo->simplify_thunk_statements();
|
|
|
160
|
|
|
161 // Write out queued up functions for hash and comparison of types.
|
|
|
162 ::gogo->write_specific_type_functions();
|
|
|
163
|
|
|
164 // Add write barriers.
|
|
|
165 ::gogo->add_write_barriers();
|
|
|
166
|
|
|
167 // Flatten the parse tree.
|
|
|
168 ::gogo->flatten();
|
|
|
169
|
|
131
|
170 // Reclaim memory of escape analysis Nodes.
|
|
|
171 ::gogo->reclaim_escape_nodes();
|
|
|
172
|
|
111
|
173 // Dump ast, use filename[0] as the base name
|
|
|
174 ::gogo->dump_ast(filenames[0]);
|
|
|
175 }
|
|
|
176
|
|
|
177 // Write out globals.
|
|
|
178
|
|
|
179 GO_EXTERN_C
|
|
|
180 void
|
|
|
181 go_write_globals()
|
|
|
182 {
|
|
|
183 return ::gogo->write_globals();
|
|
|
184 }
|
|
|
185
|
|
|
186 // Return the global IR structure. This is used by some of the
|
|
|
187 // langhooks to pass to other code.
|
|
|
188
|
|
|
189 Gogo*
|
|
|
190 go_get_gogo()
|
|
|
191 {
|
|
|
192 return ::gogo;
|
|
|
193 }
|
