This is to prevent the case of when generating the methods of a struct
type, we don't accidentally emit an inline function that references it,
as the outer struct itself would still be incomplete.
gcc/d/ChangeLog:
* d-tree.h (d_defer_declaration): Declare.
* decl.cc (function_needs_inline_definition_p): Defer checking
DECL_UNINLINABLE and DECL_DECLARED_INLINE_P.
(maybe_build_decl_tree): Call d_defer_declaration instead of
build_decl_tree.
* modules.cc (deferred_inline_declarations): New variable.
(build_module_tree): Set deferred_inline_declarations and a handle
declarations pushed to it.
(d_defer_declaration): New function.
(cherry picked from commit
8db5b71e212debcc4f6a17f80191ca187c307fcb)
extern void build_module_tree (Module *);
extern tree d_module_context (void);
extern void register_module_decl (Declaration *);
+extern void d_defer_declaration (Declaration *);
extern void d_finish_compilation (tree *, int);
/* In runtime.cc. */
if (!DECL_EXTERNAL (fd->csym))
return false;
- /* Non-inlineable functions are always external. */
- if (DECL_UNINLINABLE (fd->csym))
- return false;
-
/* No function body available for inlining. */
if (!fd->fbody)
return false;
- /* Ignore functions that aren't decorated with `pragma(inline)'. */
- if (fd->inlining != PINLINE::always)
- return false;
-
/* These functions are tied to the module they are defined in. */
if (fd->isFuncLiteralDeclaration ()
|| fd->isUnitTestDeclaration ()
if (function_defined_in_root_p (fd))
return false;
+ /* Non-inlineable functions are always external. */
+ if (DECL_UNINLINABLE (fd->csym))
+ return false;
+
+ /* Ignore functions that aren't decorated with `pragma(inline)'. */
+ if (!DECL_DECLARED_INLINE_P (fd->csym))
+ return false;
+
/* Weak functions cannot be inlined. */
if (lookup_attribute ("weak", DECL_ATTRIBUTES (fd->csym)))
return false;
return true;
}
-/* If the variable or function declaration in DECL needs to be defined, call
- build_decl_tree on it now before returning its back-end symbol. */
+/* If the variable or function declaration in DECL needs to be defined, add it
+ to the list of deferred declarations to build later. */
static tree
maybe_build_decl_tree (Declaration *decl)
if (function_needs_inline_definition_p (fd))
{
DECL_EXTERNAL (fd->csym) = 0;
- build_decl_tree (fd);
+ d_defer_declaration (fd);
}
}
static Module *current_module_decl;
+/* Any inline symbols that were deferred during codegen. */
+vec<Declaration *> *deferred_inline_declarations;
+
/* Returns an internal function identified by IDENT. This is used
by both module initialization and dso handlers. */
current_testing_module = &mitest;
current_module_decl = decl;
+ vec<Declaration *> deferred_decls = vNULL;
+ deferred_inline_declarations = &deferred_decls;
+
/* Layout module members. */
if (decl->members)
{
layout_moduleinfo (decl);
}
+ /* Process all deferred functions after finishing module. */
+ for (size_t i = 0; i < deferred_decls.length (); ++i)
+ build_decl_tree (deferred_decls[i]);
+
current_moduleinfo = NULL;
current_testing_module = NULL;
current_module_decl = NULL;
+ deferred_inline_declarations = NULL;
}
/* Returns the current function or module context for the purpose
}
}
+/* Add DECL as a declaration to emit at the end of the current module. */
+
+void
+d_defer_declaration (Declaration *decl)
+{
+ gcc_assert (deferred_inline_declarations != NULL);
+ deferred_inline_declarations->safe_push (decl);
+}
+
/* Wrapup all global declarations and start the final compilation. */
void