1 // Copyright (C) 2020-2023 Free Software Foundation, Inc.
2
3 // This file is part of GCC.
4
5 // GCC is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU General Public License as published by the Free
7 // Software Foundation; either version 3, or (at your option) any later
8 // version.
9
10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 // for more details.
14
15 // You should have received a copy of the GNU General Public License
16 // along with GCC; see the file COPYING3. If not see
17 // <http://www.gnu.org/licenses/>.
18
19 #ifndef RUST_COMPILE_EXTERN_ITEM
20 #define RUST_COMPILE_EXTERN_ITEM
21
22 #include "rust-compile-base.h"
23 #include "rust-compile-intrinsic.h"
24
25 namespace Rust {
26 namespace Compile {
27
28 class CompileExternItem : public HIRCompileBase,
29 public HIR::HIRExternalItemVisitor
30 {
31 public:
32 static tree compile (HIR::ExternalItem *item, Context *ctx,
33 TyTy::BaseType *concrete = nullptr,
34 bool is_query_mode = false,
35 Location ref_locus = Location ())
36 {
37 CompileExternItem compiler (ctx, concrete, ref_locus);
38 item->accept_vis (compiler);
39
40 if (is_query_mode && compiler.reference == error_mark_node)
41 rust_internal_error_at (ref_locus, "failed to compile extern item: %s",
42 item->as_string ().c_str ());
43
44 return compiler.reference;
45 }
46
47 void visit (HIR::ExternalStaticItem &item) override
48 {
49 // check if its already been compiled
50 Bvariable *lookup = ctx->get_backend ()->error_variable ();
51 if (ctx->lookup_var_decl (item.get_mappings ().get_hirid (), &lookup))
52 {
53 reference = ctx->get_backend ()->var_expression (lookup, ref_locus);
54 return;
55 }
56
57 TyTy::BaseType *resolved_type = nullptr;
58 bool ok = ctx->get_tyctx ()->lookup_type (item.get_mappings ().get_hirid (),
59 &resolved_type);
60 rust_assert (ok);
61
62 std::string name = item.get_item_name ();
63 // FIXME this is assuming C ABI
64 std::string asm_name = name;
65
66 tree type = TyTyResolveCompile::compile (ctx, resolved_type);
67 bool is_external = true;
68 bool is_hidden = false;
69 bool in_unique_section = false;
70
71 Bvariable *static_global
72 = ctx->get_backend ()->global_variable (name, asm_name, type, is_external,
73 is_hidden, in_unique_section,
74 item.get_locus ());
75 ctx->insert_var_decl (item.get_mappings ().get_hirid (), static_global);
76 ctx->push_var (static_global);
77
78 reference = ctx->get_backend ()->var_expression (static_global, ref_locus);
79 }
80
81 void visit (HIR::ExternalFunctionItem &function) override
82 {
83 TyTy::BaseType *fntype_tyty;
84 if (!ctx->get_tyctx ()->lookup_type (function.get_mappings ().get_hirid (),
85 &fntype_tyty))
86 {
87 rust_fatal_error (function.get_locus (),
88 "failed to lookup function type");
89 return;
90 }
91
92 rust_assert (fntype_tyty->get_kind () == TyTy::TypeKind::FNDEF);
93 TyTy::FnType *fntype = static_cast<TyTy::FnType *> (fntype_tyty);
94 if (fntype->has_subsititions_defined ())
95 {
96 // we cant do anything for this only when it is used and a concrete type
97 // is given
98 if (concrete == nullptr)
99 return;
100 else
101 {
102 rust_assert (concrete->get_kind () == TyTy::TypeKind::FNDEF);
103 fntype = static_cast<TyTy::FnType *> (concrete);
104 }
105 }
106
107 // items can be forward compiled which means we may not need to invoke this
108 // code. We might also have already compiled this generic function as well.
109 tree lookup = NULL_TREE;
110 if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup,
111 fntype->get_id (), fntype))
112 {
113 reference = address_expression (lookup, ref_locus);
114 return;
115 }
116
117 if (fntype->has_subsititions_defined ())
118 {
119 // override the Hir Lookups for the substituions in this context
120 fntype->override_context ();
121 }
122
123 if (fntype->get_abi () == ABI::INTRINSIC)
124 {
125 Intrinsics compile (ctx);
126 tree fndecl = compile.compile (fntype);
127 ctx->insert_function_decl (fntype, fndecl);
128 return;
129 }
130
131 tree compiled_fn_type = TyTyResolveCompile::compile (ctx, fntype);
132 std::string ir_symbol_name = function.get_item_name ();
133 std::string asm_name = function.get_item_name ();
134 if (fntype->get_abi () == ABI::RUST)
135 {
136 // then we need to get the canonical path of it and mangle it
137 const Resolver::CanonicalPath *canonical_path = nullptr;
138 bool ok = ctx->get_mappings ()->lookup_canonical_path (
139 function.get_mappings ().get_nodeid (), &canonical_path);
140 rust_assert (ok);
141
142 ir_symbol_name = canonical_path->get () + fntype->subst_as_string ();
143 asm_name = ctx->mangle_item (fntype, *canonical_path);
144 }
145
146 const unsigned int flags = Backend::function_is_declaration;
147 tree fndecl
148 = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name,
149 asm_name, flags, function.get_locus ());
150 TREE_PUBLIC (fndecl) = 1;
151 setup_abi_options (fndecl, fntype->get_abi ());
152
153 ctx->insert_function_decl (fntype, fndecl);
154
155 reference = address_expression (fndecl, ref_locus);
156 }
157
158 private:
159 CompileExternItem (Context *ctx, TyTy::BaseType *concrete, Location ref_locus)
160 : HIRCompileBase (ctx), concrete (concrete), reference (error_mark_node),
161 ref_locus (ref_locus)
162 {}
163
164 TyTy::BaseType *concrete;
165 tree reference;
166 Location ref_locus;
167 };
168
169 } // namespace Compile
170 } // namespace Rust
171
172 #endif // RUST_COMPILE_EXTERN_ITEM