mirror of
https://github.com/ziglang/zig.git
synced 2026-01-07 14:03:26 +00:00
f8fe517d12
We were caching the ConstExprValue of string literals, which works if you can never modify ConstExprValues. This premise is broken with `comptime var ...`. So I implemented an optimization in ConstExprValue arrays, where it stores a `Buf *` directly rather than an array of ConstExprValues for the elements, and then similar to array of undefined, it is expanded into the canonical form when necessary. However many operations can happen directly on the `Buf *`, which is faster. Furthermore, before a ConstExprValue array is expanded into canonical form, it removes itself from the string literal cache. This fixes the issue, because before an array element is modified it would have to be expanded. closes #1076
220 lines
11 KiB
C++
220 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2015 Andrew Kelley
|
|
*
|
|
* This file is part of zig, which is MIT licensed.
|
|
* See http://opensource.org/licenses/MIT
|
|
*/
|
|
|
|
#ifndef ZIG_ANALYZE_HPP
|
|
#define ZIG_ANALYZE_HPP
|
|
|
|
#include "all_types.hpp"
|
|
#include "result.hpp"
|
|
|
|
void semantic_analyze(CodeGen *g);
|
|
ErrorMsg *add_node_error(CodeGen *g, AstNode *node, Buf *msg);
|
|
ErrorMsg *add_error_note(CodeGen *g, ErrorMsg *parent_msg, AstNode *node, Buf *msg);
|
|
ZigType *new_type_table_entry(ZigTypeId id);
|
|
ZigType *get_pointer_to_type(CodeGen *g, ZigType *child_type, bool is_const);
|
|
ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_const,
|
|
bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count);
|
|
uint64_t type_size(CodeGen *g, ZigType *type_entry);
|
|
uint64_t type_size_bits(CodeGen *g, ZigType *type_entry);
|
|
ZigType *get_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits);
|
|
ZigType **get_c_int_type_ptr(CodeGen *g, CIntType c_int_type);
|
|
ZigType *get_c_int_type(CodeGen *g, CIntType c_int_type);
|
|
ZigType *get_fn_type(CodeGen *g, FnTypeId *fn_type_id);
|
|
ZigType *get_optional_type(CodeGen *g, ZigType *child_type);
|
|
ZigType *get_array_type(CodeGen *g, ZigType *child_type, uint64_t array_size);
|
|
ZigType *get_slice_type(CodeGen *g, ZigType *ptr_type);
|
|
ZigType *get_partial_container_type(CodeGen *g, Scope *scope, ContainerKind kind,
|
|
AstNode *decl_node, const char *name, ContainerLayout layout);
|
|
ZigType *get_smallest_unsigned_int_type(CodeGen *g, uint64_t x);
|
|
ZigType *get_error_union_type(CodeGen *g, ZigType *err_set_type, ZigType *payload_type);
|
|
ZigType *get_bound_fn_type(CodeGen *g, ZigFn *fn_entry);
|
|
ZigType *get_opaque_type(CodeGen *g, Scope *scope, AstNode *source_node, const char *name);
|
|
ZigType *get_struct_type(CodeGen *g, const char *type_name, const char *field_names[],
|
|
ZigType *field_types[], size_t field_count);
|
|
ZigType *get_promise_type(CodeGen *g, ZigType *result_type);
|
|
ZigType *get_promise_frame_type(CodeGen *g, ZigType *return_type);
|
|
ZigType *get_test_fn_type(CodeGen *g);
|
|
bool handle_is_ptr(ZigType *type_entry);
|
|
void find_libc_include_path(CodeGen *g);
|
|
void find_libc_lib_path(CodeGen *g);
|
|
|
|
bool type_has_bits(ZigType *type_entry);
|
|
|
|
|
|
ImportTableEntry *add_source_file(CodeGen *g, PackageTableEntry *package, Buf *abs_full_path, Buf *source_code);
|
|
|
|
|
|
ZigVar *find_variable(CodeGen *g, Scope *orig_context, Buf *name, ScopeFnDef **crossed_fndef_scope);
|
|
Tld *find_decl(CodeGen *g, Scope *scope, Buf *name);
|
|
void resolve_top_level_decl(CodeGen *g, Tld *tld, bool pointer_only, AstNode *source_node);
|
|
bool type_is_codegen_pointer(ZigType *type);
|
|
|
|
ZigType *get_src_ptr_type(ZigType *type);
|
|
ZigType *get_codegen_ptr_type(ZigType *type);
|
|
uint32_t get_ptr_align(CodeGen *g, ZigType *type);
|
|
bool get_ptr_const(ZigType *type);
|
|
ZigType *validate_var_type(CodeGen *g, AstNode *source_node, ZigType *type_entry);
|
|
ZigType *container_ref_type(ZigType *type_entry);
|
|
bool type_is_complete(ZigType *type_entry);
|
|
bool type_is_resolved(ZigType *type_entry, ResolveStatus status);
|
|
bool type_is_invalid(ZigType *type_entry);
|
|
bool type_is_global_error_set(ZigType *err_set_type);
|
|
void resolve_container_type(CodeGen *g, ZigType *type_entry);
|
|
ScopeDecls *get_container_scope(ZigType *type_entry);
|
|
TypeStructField *find_struct_type_field(ZigType *type_entry, Buf *name);
|
|
TypeEnumField *find_enum_type_field(ZigType *enum_type, Buf *name);
|
|
TypeUnionField *find_union_type_field(ZigType *type_entry, Buf *name);
|
|
TypeEnumField *find_enum_field_by_tag(ZigType *enum_type, const BigInt *tag);
|
|
TypeUnionField *find_union_field_by_tag(ZigType *type_entry, const BigInt *tag);
|
|
|
|
bool is_ref(ZigType *type_entry);
|
|
bool is_array_ref(ZigType *type_entry);
|
|
bool is_container_ref(ZigType *type_entry);
|
|
void scan_decls(CodeGen *g, ScopeDecls *decls_scope, AstNode *node);
|
|
void scan_import(CodeGen *g, ImportTableEntry *import);
|
|
void preview_use_decl(CodeGen *g, AstNode *node);
|
|
void resolve_use_decl(CodeGen *g, AstNode *node);
|
|
ZigFn *scope_fn_entry(Scope *scope);
|
|
ImportTableEntry *get_scope_import(Scope *scope);
|
|
void init_tld(Tld *tld, TldId id, Buf *name, VisibMod visib_mod, AstNode *source_node, Scope *parent_scope);
|
|
ZigVar *add_variable(CodeGen *g, AstNode *source_node, Scope *parent_scope, Buf *name,
|
|
bool is_const, ConstExprValue *init_value, Tld *src_tld);
|
|
ZigType *analyze_type_expr(CodeGen *g, Scope *scope, AstNode *node);
|
|
ZigFn *create_fn(CodeGen *g, AstNode *proto_node);
|
|
ZigFn *create_fn_raw(CodeGen *g, FnInline inline_value);
|
|
void init_fn_type_id(FnTypeId *fn_type_id, AstNode *proto_node, size_t param_count_alloc);
|
|
AstNode *get_param_decl_node(ZigFn *fn_entry, size_t index);
|
|
bool type_requires_comptime(ZigType *type_entry);
|
|
Error ATTRIBUTE_MUST_USE ensure_complete_type(CodeGen *g, ZigType *type_entry);
|
|
Error ATTRIBUTE_MUST_USE type_resolve(CodeGen *g, ZigType *type_entry, ResolveStatus status);
|
|
void complete_enum(CodeGen *g, ZigType *enum_type);
|
|
bool ir_get_var_is_comptime(ZigVar *var);
|
|
bool const_values_equal(CodeGen *g, ConstExprValue *a, ConstExprValue *b);
|
|
void eval_min_max_value(CodeGen *g, ZigType *type_entry, ConstExprValue *const_val, bool is_max);
|
|
void eval_min_max_value_int(CodeGen *g, ZigType *int_type, BigInt *bigint, bool is_max);
|
|
|
|
void render_const_value(CodeGen *g, Buf *buf, ConstExprValue *const_val);
|
|
void analyze_fn_ir(CodeGen *g, ZigFn *fn_table_entry, AstNode *return_type_node);
|
|
|
|
ScopeBlock *create_block_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
ScopeDefer *create_defer_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
ScopeDeferExpr *create_defer_expr_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
Scope *create_var_scope(CodeGen *g, AstNode *node, Scope *parent, ZigVar *var);
|
|
ScopeCImport *create_cimport_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
ScopeLoop *create_loop_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
ScopeSuspend *create_suspend_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
ScopeFnDef *create_fndef_scope(CodeGen *g, AstNode *node, Scope *parent, ZigFn *fn_entry);
|
|
ScopeDecls *create_decls_scope(CodeGen *g, AstNode *node, Scope *parent, ZigType *container_type, ImportTableEntry *import);
|
|
Scope *create_comptime_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
Scope *create_coro_prelude_scope(CodeGen *g, AstNode *node, Scope *parent);
|
|
Scope *create_runtime_scope(CodeGen *g, AstNode *node, Scope *parent, IrInstruction *is_comptime);
|
|
|
|
void init_const_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *str);
|
|
ConstExprValue *create_const_str_lit(CodeGen *g, Buf *str);
|
|
|
|
void init_const_c_str_lit(CodeGen *g, ConstExprValue *const_val, Buf *c_str);
|
|
ConstExprValue *create_const_c_str_lit(CodeGen *g, Buf *c_str);
|
|
|
|
void init_const_bigint(ConstExprValue *const_val, ZigType *type, const BigInt *bigint);
|
|
ConstExprValue *create_const_bigint(ZigType *type, const BigInt *bigint);
|
|
|
|
void init_const_unsigned_negative(ConstExprValue *const_val, ZigType *type, uint64_t x, bool negative);
|
|
ConstExprValue *create_const_unsigned_negative(ZigType *type, uint64_t x, bool negative);
|
|
|
|
void init_const_signed(ConstExprValue *const_val, ZigType *type, int64_t x);
|
|
ConstExprValue *create_const_signed(ZigType *type, int64_t x);
|
|
|
|
void init_const_usize(CodeGen *g, ConstExprValue *const_val, uint64_t x);
|
|
ConstExprValue *create_const_usize(CodeGen *g, uint64_t x);
|
|
|
|
void init_const_float(ConstExprValue *const_val, ZigType *type, double value);
|
|
ConstExprValue *create_const_float(ZigType *type, double value);
|
|
|
|
void init_const_enum(ConstExprValue *const_val, ZigType *type, const BigInt *tag);
|
|
ConstExprValue *create_const_enum(ZigType *type, const BigInt *tag);
|
|
|
|
void init_const_bool(CodeGen *g, ConstExprValue *const_val, bool value);
|
|
ConstExprValue *create_const_bool(CodeGen *g, bool value);
|
|
|
|
void init_const_type(CodeGen *g, ConstExprValue *const_val, ZigType *type_value);
|
|
ConstExprValue *create_const_type(CodeGen *g, ZigType *type_value);
|
|
|
|
void init_const_runtime(ConstExprValue *const_val, ZigType *type);
|
|
ConstExprValue *create_const_runtime(ZigType *type);
|
|
|
|
void init_const_ptr_ref(CodeGen *g, ConstExprValue *const_val, ConstExprValue *pointee_val, bool is_const);
|
|
ConstExprValue *create_const_ptr_ref(CodeGen *g, ConstExprValue *pointee_val, bool is_const);
|
|
|
|
void init_const_ptr_hard_coded_addr(CodeGen *g, ConstExprValue *const_val, ZigType *pointee_type,
|
|
size_t addr, bool is_const);
|
|
ConstExprValue *create_const_ptr_hard_coded_addr(CodeGen *g, ZigType *pointee_type,
|
|
size_t addr, bool is_const);
|
|
|
|
void init_const_ptr_array(CodeGen *g, ConstExprValue *const_val, ConstExprValue *array_val,
|
|
size_t elem_index, bool is_const, PtrLen ptr_len);
|
|
ConstExprValue *create_const_ptr_array(CodeGen *g, ConstExprValue *array_val, size_t elem_index,
|
|
bool is_const, PtrLen ptr_len);
|
|
|
|
void init_const_slice(CodeGen *g, ConstExprValue *const_val, ConstExprValue *array_val,
|
|
size_t start, size_t len, bool is_const);
|
|
ConstExprValue *create_const_slice(CodeGen *g, ConstExprValue *array_val, size_t start, size_t len, bool is_const);
|
|
|
|
void init_const_arg_tuple(CodeGen *g, ConstExprValue *const_val, size_t arg_index_start, size_t arg_index_end);
|
|
ConstExprValue *create_const_arg_tuple(CodeGen *g, size_t arg_index_start, size_t arg_index_end);
|
|
|
|
void init_const_undefined(CodeGen *g, ConstExprValue *const_val);
|
|
|
|
ConstExprValue *create_const_vals(size_t count);
|
|
|
|
ZigType *make_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits);
|
|
ConstParent *get_const_val_parent(CodeGen *g, ConstExprValue *value);
|
|
void expand_undef_array(CodeGen *g, ConstExprValue *const_val);
|
|
void update_compile_var(CodeGen *g, Buf *name, ConstExprValue *value);
|
|
|
|
const char *type_id_name(ZigTypeId id);
|
|
ZigTypeId type_id_at_index(size_t index);
|
|
size_t type_id_len();
|
|
size_t type_id_index(ZigType *entry);
|
|
ZigType *get_generic_fn_type(CodeGen *g, FnTypeId *fn_type_id);
|
|
Result<bool> type_is_copyable(CodeGen *g, ZigType *type_entry);
|
|
LinkLib *create_link_lib(Buf *name);
|
|
LinkLib *add_link_lib(CodeGen *codegen, Buf *lib);
|
|
|
|
uint32_t get_abi_alignment(CodeGen *g, ZigType *type_entry);
|
|
ZigType *get_align_amt_type(CodeGen *g);
|
|
PackageTableEntry *new_anonymous_package(void);
|
|
|
|
Buf *const_value_to_buffer(ConstExprValue *const_val);
|
|
void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, Buf *symbol_name, GlobalLinkageId linkage, bool ccc);
|
|
|
|
|
|
ConstExprValue *get_builtin_value(CodeGen *codegen, const char *name);
|
|
ZigType *get_ptr_to_stack_trace_type(CodeGen *g);
|
|
bool resolve_inferred_error_set(CodeGen *g, ZigType *err_set_type, AstNode *source_node);
|
|
|
|
ZigType *get_auto_err_set_type(CodeGen *g, ZigFn *fn_entry);
|
|
|
|
uint32_t get_coro_frame_align_bytes(CodeGen *g);
|
|
bool fn_type_can_fail(FnTypeId *fn_type_id);
|
|
bool type_can_fail(ZigType *type_entry);
|
|
bool fn_eval_cacheable(Scope *scope, ZigType *return_type);
|
|
AstNode *type_decl_node(ZigType *type_entry);
|
|
|
|
ZigType *get_primitive_type(CodeGen *g, Buf *name);
|
|
|
|
bool calling_convention_allows_zig_types(CallingConvention cc);
|
|
const char *calling_convention_name(CallingConvention cc);
|
|
|
|
Error ATTRIBUTE_MUST_USE file_fetch(CodeGen *g, Buf *resolved_path, Buf *contents);
|
|
|
|
void walk_function_params(CodeGen *g, ZigType *fn_type, FnWalk *fn_walk);
|
|
X64CABIClass type_c_abi_x86_64_class(CodeGen *g, ZigType *ty);
|
|
bool type_is_c_abi_int(CodeGen *g, ZigType *ty);
|
|
bool want_first_arg_sret(CodeGen *g, FnTypeId *fn_type_id);
|
|
|
|
#endif
|