|
| 1 | +// Copyright (C) 2020 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-tyty.h" |
| 24 | +#include "rust-compile-implitem.h" |
| 25 | +#include "rust-compile-var-decl.h" |
| 26 | +#include "rust-compile-stmt.h" |
| 27 | +#include "rust-compile-expr.h" |
| 28 | +#include "rust-compile-fnparam.h" |
| 29 | + |
| 30 | +namespace Rust { |
| 31 | +namespace Compile { |
| 32 | + |
| 33 | +class CompileExternItem : public HIRCompileBase |
| 34 | +{ |
| 35 | + using Rust::Compile::HIRCompileBase::visit; |
| 36 | + |
| 37 | +public: |
| 38 | + static void compile (HIR::ExternalItem *item, Context *ctx, |
| 39 | + bool compile_fns = true, |
| 40 | + TyTy::BaseType *concrete = nullptr) |
| 41 | + { |
| 42 | + CompileExternItem compiler (ctx, compile_fns, concrete); |
| 43 | + item->accept_vis (compiler); |
| 44 | + } |
| 45 | + |
| 46 | + void visit (HIR::ExternalStaticItem &item) override |
| 47 | + { |
| 48 | + TyTy::BaseType *resolved_type = nullptr; |
| 49 | + bool ok = ctx->get_tyctx ()->lookup_type (item.get_mappings ().get_hirid (), |
| 50 | + &resolved_type); |
| 51 | + rust_assert (ok); |
| 52 | + |
| 53 | + std::string name = item.get_item_name (); |
| 54 | + // FIXME this is assuming C ABI |
| 55 | + std::string asm_name = name; |
| 56 | + |
| 57 | + Btype *type = TyTyResolveCompile::compile (ctx, resolved_type); |
| 58 | + bool is_external = true; |
| 59 | + bool is_hidden = false; |
| 60 | + bool in_unique_section = false; |
| 61 | + |
| 62 | + Bvariable *static_global |
| 63 | + = ctx->get_backend ()->global_variable (name, asm_name, type, is_external, |
| 64 | + is_hidden, in_unique_section, |
| 65 | + item.get_locus ()); |
| 66 | + ctx->insert_var_decl (item.get_mappings ().get_hirid (), static_global); |
| 67 | + ctx->push_var (static_global); |
| 68 | + } |
| 69 | + |
| 70 | + void visit (HIR::ExternalFunctionItem &function) override |
| 71 | + { |
| 72 | + if (!compile_fns) |
| 73 | + return; |
| 74 | + |
| 75 | + TyTy::BaseType *fntype_tyty; |
| 76 | + if (!ctx->get_tyctx ()->lookup_type (function.get_mappings ().get_hirid (), |
| 77 | + &fntype_tyty)) |
| 78 | + { |
| 79 | + rust_fatal_error (function.get_locus (), |
| 80 | + "failed to lookup function type"); |
| 81 | + return; |
| 82 | + } |
| 83 | + |
| 84 | + rust_assert (fntype_tyty->get_kind () == TyTy::TypeKind::FNDEF); |
| 85 | + TyTy::FnType *fntype = static_cast<TyTy::FnType *> (fntype_tyty); |
| 86 | + if (fntype->has_subsititions_defined ()) |
| 87 | + { |
| 88 | + // we cant do anything for this only when it is used and a concrete type |
| 89 | + // is given |
| 90 | + if (concrete == nullptr) |
| 91 | + return; |
| 92 | + else |
| 93 | + { |
| 94 | + rust_assert (concrete->get_kind () == TyTy::TypeKind::FNDEF); |
| 95 | + fntype = static_cast<TyTy::FnType *> (concrete); |
| 96 | + } |
| 97 | + } |
| 98 | + |
| 99 | + // items can be forward compiled which means we may not need to invoke this |
| 100 | + // code. We might also have already compiled this generic function as well. |
| 101 | + Bfunction *lookup = nullptr; |
| 102 | + if (ctx->lookup_function_decl (fntype->get_ty_ref (), &lookup, fntype)) |
| 103 | + { |
| 104 | + // has this been added to the list then it must be finished |
| 105 | + if (ctx->function_completed (lookup)) |
| 106 | + { |
| 107 | + Bfunction *dummy = nullptr; |
| 108 | + if (!ctx->lookup_function_decl (fntype->get_ty_ref (), &dummy)) |
| 109 | + ctx->insert_function_decl (fntype->get_ty_ref (), lookup, fntype); |
| 110 | + |
| 111 | + return; |
| 112 | + } |
| 113 | + } |
| 114 | + |
| 115 | + if (fntype->has_subsititions_defined ()) |
| 116 | + { |
| 117 | + // override the Hir Lookups for the substituions in this context |
| 118 | + fntype->override_context (); |
| 119 | + } |
| 120 | + |
| 121 | + ::Btype *compiled_fn_type = TyTyResolveCompile::compile (ctx, fntype); |
| 122 | + |
| 123 | + const unsigned int flags |
| 124 | + = Backend::function_is_declaration | Backend::function_is_visible; |
| 125 | + |
| 126 | + std::string ir_symbol_name = function.get_item_name (); |
| 127 | + // FIXME this assumes C ABI |
| 128 | + std::string asm_name = function.get_item_name (); |
| 129 | + |
| 130 | + Bfunction *fndecl |
| 131 | + = ctx->get_backend ()->function (compiled_fn_type, ir_symbol_name, |
| 132 | + asm_name, flags, function.get_locus ()); |
| 133 | + ctx->insert_function_decl (fntype->get_ty_ref (), fndecl, fntype); |
| 134 | + } |
| 135 | + |
| 136 | +private: |
| 137 | + CompileExternItem (Context *ctx, bool compile_fns, TyTy::BaseType *concrete) |
| 138 | + : HIRCompileBase (ctx), compile_fns (compile_fns), concrete (concrete) |
| 139 | + {} |
| 140 | + |
| 141 | + bool compile_fns; |
| 142 | + TyTy::BaseType *concrete; |
| 143 | +}; |
| 144 | + |
| 145 | +} // namespace Compile |
| 146 | +} // namespace Rust |
| 147 | + |
| 148 | +#endif // RUST_COMPILE_EXTERN_ITEM |
![bors[bot]](https://avatars.githubusercontent.com/in/1847?v=4&size=40){kind=avatar}
0 commit comments