void rest_of_type_compilation (tree type, int toplev) { /* Avoid confusing the debug information machinery when there are errors. */ if (errorcount != 0 || sorrycount != 0) return; /* LLVM LOCAL begin */ #ifndef ENABLE_LLVM timevar_push (TV_SYMOUT); debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev); timevar_pop (TV_SYMOUT); #else llvm_emit_typedef (TYPE_STUB_DECL (type)); toplev = toplev; /* avoid unused var warning */ #endif /* LLVM LOCAL end */ }
void rest_of_type_compilation (tree type, int toplev) { /* Avoid confusing the debug information machinery when there are errors. */ if (errorcount != 0 || sorrycount != 0) return; timevar_push (TV_SYMOUT); debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev); timevar_pop (TV_SYMOUT); }
static void lto_input_ts_type_common_tree_pointers (struct lto_input_block *ib, struct data_in *data_in, tree expr) { TYPE_SIZE (expr) = stream_read_tree (ib, data_in); TYPE_SIZE_UNIT (expr) = stream_read_tree (ib, data_in); TYPE_ATTRIBUTES (expr) = stream_read_tree (ib, data_in); TYPE_NAME (expr) = stream_read_tree (ib, data_in); /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be reconstructed during fixup. */ /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists during fixup. */ TYPE_MAIN_VARIANT (expr) = stream_read_tree (ib, data_in); TYPE_CONTEXT (expr) = stream_read_tree (ib, data_in); /* TYPE_CANONICAL gets re-computed during type merging. */ TYPE_CANONICAL (expr) = NULL_TREE; TYPE_STUB_DECL (expr) = stream_read_tree (ib, data_in); }
static void write_ts_type_common_tree_pointers (struct output_block *ob, tree expr, bool ref_p) { stream_write_tree (ob, TYPE_SIZE (expr), ref_p); stream_write_tree (ob, TYPE_SIZE_UNIT (expr), ref_p); stream_write_tree (ob, TYPE_ATTRIBUTES (expr), ref_p); stream_write_tree (ob, TYPE_NAME (expr), ref_p); /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be reconstructed during fixup. */ /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists during fixup. */ stream_write_tree (ob, TYPE_MAIN_VARIANT (expr), ref_p); stream_write_tree (ob, TYPE_CONTEXT (expr), ref_p); /* TYPE_CANONICAL is re-computed during type merging, so no need to stream it here. */ stream_write_tree (ob, TYPE_STUB_DECL (expr), ref_p); }
tree build_java_array_type (tree element_type, HOST_WIDE_INT length) { tree sig, t, fld, atype, arfld; char buf[23]; tree elsig = build_java_signature (element_type); tree el_name = element_type; buf[0] = '['; if (length >= 0) sprintf (buf+1, HOST_WIDE_INT_PRINT_DEC, length); else buf[1] = '\0'; sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig), buf, 0, 0, ""); t = IDENTIFIER_SIGNATURE_TYPE (sig); if (t != NULL_TREE) return TREE_TYPE (t); t = make_class (); IDENTIFIER_SIGNATURE_TYPE (sig) = build_pointer_type (t); TYPE_ARRAY_P (t) = 1; if (TREE_CODE (el_name) == POINTER_TYPE) el_name = TREE_TYPE (el_name); el_name = TYPE_NAME (el_name); if (TREE_CODE (el_name) == TYPE_DECL) el_name = DECL_NAME (el_name); { char suffix[23]; if (length >= 0) sprintf (suffix, "[%d]", (int)length); else strcpy (suffix, "[]"); TYPE_NAME (t) = TYPE_STUB_DECL (t) = build_decl (input_location, TYPE_DECL, identifier_subst (el_name, "", '.', '.', suffix), t); TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (t)) = true; } set_java_signature (t, sig); set_super_info (0, t, object_type_node, 0); if (TREE_CODE (element_type) == RECORD_TYPE) element_type = promote_type (element_type); TYPE_ARRAY_ELEMENT (t) = element_type; /* Add length pseudo-field. */ fld = build_decl (input_location, FIELD_DECL, get_identifier ("length"), int_type_node); TYPE_FIELDS (t) = fld; DECL_CONTEXT (fld) = t; FIELD_PUBLIC (fld) = 1; FIELD_FINAL (fld) = 1; TREE_READONLY (fld) = 1; atype = build_prim_array_type (element_type, length); arfld = build_decl (input_location, FIELD_DECL, get_identifier ("data"), atype); DECL_CONTEXT (arfld) = t; DECL_CHAIN (fld) = arfld; DECL_ALIGN (arfld) = TYPE_ALIGN (element_type); /* We could layout_class, but that loads java.lang.Object prematurely. * This is called by the parser, and it is a bad idea to do load_class * in the middle of parsing, because of possible circularity problems. */ push_super_field (t, object_type_node); layout_type (t); return t; }