From patchwork Thu Mar 13 20:53:02 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Malcolm X-Patchwork-Id: 330121 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 9071B2C009E for ; Fri, 14 Mar 2014 07:52:36 +1100 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id; q=dns; s=default; b=E5jdt5OKv6UU zed0K+cMu875vJ4x4Xeu6aC8h1KLXa1O6yIanDtfuPG1Wqgi3frbWrG9oMiMsWgL 1PsODgRacuSgK03u10SsaEZ+fbgsvQP2N0dbo8dmdPajTGwaIxUMMNjS/pBpSKA9 lURZ/HhgQpCPStrMcUQ4bX/ay0O6k3U= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:cc:subject:date:message-id; s=default; bh=m5qJdb4/nz9smAZuLc uRJgqidc0=; b=wz3tAqjJ9Aj9Rb4zMQfWST5RcDfCzEC6svqlzyP36lfiJGHzZ2 1ZCp/Lsz4SFkCuWOScr7wAUIhpFtV3AKe1SZzVx+B424OwHgJRV6fwssTnXI1P31 RVoqP0OGcAuJ3hhY9QggOd5ZuGRSAmslIsDNiZo31wjjlcd9tLo3IM9ls= Received: (qmail 29505 invoked by alias); 13 Mar 2014 20:52:27 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 29477 invoked by uid 89); 13 Mar 2014 20:52:26 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.2 required=5.0 tests=AWL, BAYES_00, SPF_HELO_PASS, SPF_PASS, T_FILL_THIS_FORM_SHORT, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-Spam-User: qpsmtpd, 2 recipients X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 13 Mar 2014 20:52:21 +0000 Received: from int-mx11.intmail.prod.int.phx2.redhat.com (int-mx11.intmail.prod.int.phx2.redhat.com [10.5.11.24]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s2DKqFhG016195 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK); Thu, 13 Mar 2014 16:52:16 -0400 Received: from c64.redhat.com (vpn-239-109.phx2.redhat.com [10.3.239.109]) by int-mx11.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s2DKqCqL003050; Thu, 13 Mar 2014 16:52:12 -0400 From: David Malcolm To: jit@gcc.gnu.org, gcc-patches@gcc.gnu.org Cc: David Malcolm Subject: [jit] Include locations in error reports where available Date: Thu, 13 Mar 2014 16:53:02 -0400 Message-Id: <1394743982-32385-1-git-send-email-dmalcolm@redhat.com> X-IsSubscribed: yes Committed to branch dmalcolm/jit: Update the error-handling machinery to pass around (recording::location *) values (aka a gcc_jit_location *), printing them when reporting errors, where available (they can be NULL). Also, in gcc::jit::recording::context::errors_occurred, consider errors as having occurred if they occured on a parent (or ancestor) context. gcc/jit/ * internal-api.c (gcc::jit::recording::context::set_str_option): Provide NULL recording::location to add_error. (gcc::jit::recording::context::set_int_option): Likewise. (gcc::jit::recording::context::set_bool_option): Likewise. (gcc::jit::playback::context::compile): Likewise. (gcc::jit::recording::context::add_error): Add recording::location param. (gcc::jit::recording::context::add_error_va): Likewise; print it when present; add "error: " to stderr messages. (gcc::jit::recording::location::replay_into): Provide recording::location to the playback::location. (gcc::jit::recording::function::validate): Add locations to the add_error invocations. (gcc::jit::recording::block::validate): Likewise. (gcc::jit::playback::context::get_type): Likewise. (gcc::jit::playback::context::new_unary_op): Likewise. (gcc::jit::playback::context::new_binary_op): Likewise. (gcc::jit::playback::context::new_comparison): Likewise. (gcc::jit::recording::block::get_loc): New. (gcc::jit::recording::block::get_first_statement): New. (gcc::jit::playback::context::build_cast): Pass in higher-level arguments in the hope of eventually providing better error messages when a cast isn't possible. (gcc::jit::playback::context::new_cast): As above. (gcc::jit::playback::context::add_error): Add playback::location parameter, using it to provide the corresponding recording::location (if any) when reporting the error to the recording::context. (gcc::jit::playback::context::add_error_va): Likewise. (gcc::jit::playback::context::new_location): Likewise. (gcc::jit::playback::source_line::get_location): Likewise. (gcc::jit::playback::location::location): Likewise. * internal-api.h (gcc::jit::recording::context::add_error): Add recording::location param. (gcc::jit::recording::context::add_error_va): Likewise. (gcc::jit::recording::context::errors_occurred): Also consider errors that occur on a parent or ancestor context, recursively. (gcc::jit::recording::block::get_loc): New. (gcc::jit::recording::block::get_first_statement): New. (gcc::jit::recording::statement::get_loc): New. (gcc::jit::playback::context::new_location): Add recording::location parameter. (gcc::jit::playback::context::add_error): Add playback::location parameter. (gcc::jit::playback::context::add_error_va): Likewise. (gcc::jit::playback::context::build_cast): Pass in higher-level arguments in the hope of eventually providing better error messages when a cast isn't possible. (gcc::jit::playback::source_line::get_location): Add recording::location parameter. (gcc::jit::playback::location::location): Likewise. (gcc::jit::playback::location::get_recording_loc): New. (gcc::jit::playback::location::m_recording_loc): New. * jit-builtins.c (gcc::jit::builtins_manager::get_builtin_function): Provide NULL recording::location to add_error. (gcc::jit::builtins_manager::make_primitive_type): Likewise. * libgccjit.c (RETURN_VAL_IF_FAIL): Add location argument. (RETURN_VAL_IF_FAIL_PRINTF1): Likewise. (RETURN_VAL_IF_FAIL_PRINTF2): Likewise. (RETURN_VAL_IF_FAIL_PRINTF3): Likewise. (RETURN_VAL_IF_FAIL_PRINTF4): Likewise. (RETURN_VAL_IF_FAIL_PRINTF6): Likewise. (RETURN_NULL_IF_FAIL): Likewise. (RETURN_NULL_IF_FAIL_PRINTF1): Likewise. (RETURN_NULL_IF_FAIL_PRINTF2): Likewise. (RETURN_NULL_IF_FAIL_PRINTF3): Likewise. (RETURN_NULL_IF_FAIL_PRINTF4): Likewise. (RETURN_NULL_IF_FAIL_PRINTF6): Likewise. (RETURN_IF_FAIL): Likewise. (RETURN_IF_FAIL_PRINTF1): Likewise. (RETURN_IF_FAIL_PRINTF2): Likewise. (RETURN_IF_FAIL_PRINTF4): Likewise. (RETURN_IF_NOT_VALID_BLOCK): Likewise. (RETURN_NULL_IF_NOT_VALID_BLOCK): Likewise. (jit_error): Likewise. (gcc_jit_location_as_object): Provided location argument to error-handling macros. (gcc_jit_type_as_object): Likewise. (gcc_jit_context_get_type): Likewise. (gcc_jit_context_get_int_type): Likewise. (gcc_jit_type_get_pointer): Likewise. (gcc_jit_type_get_const): Likewise. (gcc_jit_type_get_volatile): Likewise. (gcc_jit_context_new_array_type): Likewise. (gcc_jit_context_new_field): Likewise. (gcc_jit_context_new_struct_type): Likewise. (gcc_jit_context_new_opaque_struct): Likewise. (gcc_jit_struct_as_type): Likewise. (gcc_jit_struct_set_fields): Likewise. (gcc_jit_context_new_param): Likewise. (gcc_jit_param_as_object): Likewise. (gcc_jit_param_as_lvalue): Likewise. (gcc_jit_param_as_rvalue): Likewise. (gcc_jit_context_new_function): Likewise. (gcc_jit_context_get_builtin_function): Likewise. (gcc_jit_function_as_object): Likewise. (gcc_jit_function_get_param): Likewise. (gcc_jit_function_dump_to_dot): Likewise. (gcc_jit_function_new_block): Likewise. (gcc_jit_block_as_object): Likewise. (gcc_jit_block_get_function): Likewise. (gcc_jit_context_new_global): Likewise. (gcc_jit_lvalue_as_object): Likewise. (gcc_jit_lvalue_as_rvalue): Likewise. (gcc_jit_rvalue_as_object): Likewise. (gcc_jit_rvalue_get_type): Likewise. (gcc_jit_context_new_rvalue_from_int): Likewise. (gcc_jit_context_zero): Likewise. (gcc_jit_context_one): Likewise. (gcc_jit_context_new_rvalue_from_double): Likewise. (gcc_jit_context_new_rvalue_from_ptr): Likewise. (gcc_jit_context_null): Likewise. (gcc_jit_context_new_string_literal): Likewise. (gcc_jit_context_new_unary_op): Likewise. (gcc_jit_context_new_binary_op): Likewise. (gcc_jit_context_new_comparison): Likewise. (gcc_jit_context_new_call): Likewise. (gcc_jit_context_new_cast): Likewise. (gcc_jit_context_new_array_access): Likewise. (gcc_jit_object_get_context): Likewise. (gcc_jit_object_get_debug_string): Likewise. (gcc_jit_lvalue_access_field): Likewise. (gcc_jit_rvalue_access_field): Likewise. (gcc_jit_rvalue_dereference_field): Likewise. (gcc_jit_rvalue_dereference_field): Likewise. (gcc_jit_rvalue_dereference): Likewise. (gcc_jit_lvalue_get_address): Likewise. (gcc_jit_function_new_local): Likewise. (gcc_jit_block_add_eval): Likewise. (gcc_jit_block_add_assignment): Likewise. (gcc_jit_block_add_assignment_op): Likewise. (gcc_jit_block_end_with_conditional): Likewise. (gcc_jit_block_add_comment): Likewise. (gcc_jit_block_end_with_jump): Likewise. (gcc_jit_block_end_with_return): Likewise. (gcc_jit_block_end_with_void_return): Likewise. (gcc_jit_context_set_str_option): Likewise. (gcc_jit_context_set_int_option): Likewise. (gcc_jit_context_set_bool_option): Likewise. (gcc_jit_context_compile): Likewise. (gcc_jit_context_dump_to_file): Likewise. (gcc_jit_context_get_first_error): Likewise. (gcc_jit_result_get_code): Likewise. (gcc_jit_result_get_code): Likewise. (gcc_jit_result_release): Likewise. --- gcc/jit/ChangeLog.jit | 163 +++++++++++++++++++ gcc/jit/internal-api.c | 135 ++++++++++------ gcc/jit/internal-api.h | 38 +++-- gcc/jit/jit-builtins.c | 5 +- gcc/jit/libgccjit.c | 417 +++++++++++++++++++++++++------------------------ 5 files changed, 498 insertions(+), 260 deletions(-) diff --git a/gcc/jit/ChangeLog.jit b/gcc/jit/ChangeLog.jit index 2d47442..87f10a3 100644 --- a/gcc/jit/ChangeLog.jit +++ b/gcc/jit/ChangeLog.jit @@ -1,3 +1,166 @@ +2014-03-13 David Malcolm + + * internal-api.c (gcc::jit::recording::context::set_str_option): + Provide NULL recording::location to add_error. + (gcc::jit::recording::context::set_int_option): Likewise. + (gcc::jit::recording::context::set_bool_option): Likewise. + (gcc::jit::playback::context::compile): Likewise. + (gcc::jit::recording::context::add_error): Add recording::location + param. + (gcc::jit::recording::context::add_error_va): Likewise; print it + when present; add "error: " to stderr messages. + (gcc::jit::recording::location::replay_into): Provide + recording::location to the playback::location. + + (gcc::jit::recording::function::validate): Add locations to the + add_error invocations. + (gcc::jit::recording::block::validate): Likewise. + (gcc::jit::playback::context::get_type): Likewise. + (gcc::jit::playback::context::new_unary_op): Likewise. + (gcc::jit::playback::context::new_binary_op): Likewise. + (gcc::jit::playback::context::new_comparison): Likewise. + + (gcc::jit::recording::block::get_loc): New. + (gcc::jit::recording::block::get_first_statement): New. + + (gcc::jit::playback::context::build_cast): Pass in higher-level + arguments in the hope of eventually providing better error + messages when a cast isn't possible. + (gcc::jit::playback::context::new_cast): As above. + + (gcc::jit::playback::context::add_error): Add playback::location + parameter, using it to provide the corresponding + recording::location (if any) when reporting the error to the + recording::context. + (gcc::jit::playback::context::add_error_va): Likewise. + (gcc::jit::playback::context::new_location): Likewise. + (gcc::jit::playback::source_line::get_location): Likewise. + (gcc::jit::playback::location::location): Likewise. + + * internal-api.h (gcc::jit::recording::context::add_error): Add + recording::location param. + (gcc::jit::recording::context::add_error_va): Likewise. + + (gcc::jit::recording::context::errors_occurred): Also consider + errors that occur on a parent or ancestor context, recursively. + + (gcc::jit::recording::block::get_loc): New. + (gcc::jit::recording::block::get_first_statement): New. + (gcc::jit::recording::statement::get_loc): New. + + (gcc::jit::playback::context::new_location): Add recording::location + parameter. + + (gcc::jit::playback::context::add_error): Add playback::location + parameter. + (gcc::jit::playback::context::add_error_va): Likewise. + + (gcc::jit::playback::context::build_cast): Pass in higher-level + arguments in the hope of eventually providing better error + messages when a cast isn't possible. + + (gcc::jit::playback::source_line::get_location): Add + recording::location parameter. + (gcc::jit::playback::location::location): Likewise. + (gcc::jit::playback::location::get_recording_loc): New. + (gcc::jit::playback::location::m_recording_loc): New. + + * jit-builtins.c (gcc::jit::builtins_manager::get_builtin_function): + Provide NULL recording::location to add_error. + (gcc::jit::builtins_manager::make_primitive_type): Likewise. + + * libgccjit.c (RETURN_VAL_IF_FAIL): Add location argument. + (RETURN_VAL_IF_FAIL_PRINTF1): Likewise. + (RETURN_VAL_IF_FAIL_PRINTF2): Likewise. + (RETURN_VAL_IF_FAIL_PRINTF3): Likewise. + (RETURN_VAL_IF_FAIL_PRINTF4): Likewise. + (RETURN_VAL_IF_FAIL_PRINTF6): Likewise. + (RETURN_NULL_IF_FAIL): Likewise. + (RETURN_NULL_IF_FAIL_PRINTF1): Likewise. + (RETURN_NULL_IF_FAIL_PRINTF2): Likewise. + (RETURN_NULL_IF_FAIL_PRINTF3): Likewise. + (RETURN_NULL_IF_FAIL_PRINTF4): Likewise. + (RETURN_NULL_IF_FAIL_PRINTF6): Likewise. + (RETURN_IF_FAIL): Likewise. + (RETURN_IF_FAIL_PRINTF1): Likewise. + (RETURN_IF_FAIL_PRINTF2): Likewise. + (RETURN_IF_FAIL_PRINTF4): Likewise. + (RETURN_IF_NOT_VALID_BLOCK): Likewise. + (RETURN_NULL_IF_NOT_VALID_BLOCK): Likewise. + + (jit_error): Likewise. + + (gcc_jit_location_as_object): Provided location argument to + error-handling macros. + (gcc_jit_type_as_object): Likewise. + (gcc_jit_context_get_type): Likewise. + (gcc_jit_context_get_int_type): Likewise. + (gcc_jit_type_get_pointer): Likewise. + (gcc_jit_type_get_const): Likewise. + (gcc_jit_type_get_volatile): Likewise. + (gcc_jit_context_new_array_type): Likewise. + (gcc_jit_context_new_field): Likewise. + (gcc_jit_context_new_struct_type): Likewise. + (gcc_jit_context_new_opaque_struct): Likewise. + (gcc_jit_struct_as_type): Likewise. + (gcc_jit_struct_set_fields): Likewise. + (gcc_jit_context_new_param): Likewise. + (gcc_jit_param_as_object): Likewise. + (gcc_jit_param_as_lvalue): Likewise. + (gcc_jit_param_as_rvalue): Likewise. + (gcc_jit_context_new_function): Likewise. + (gcc_jit_context_get_builtin_function): Likewise. + (gcc_jit_function_as_object): Likewise. + (gcc_jit_function_get_param): Likewise. + (gcc_jit_function_dump_to_dot): Likewise. + (gcc_jit_function_new_block): Likewise. + (gcc_jit_block_as_object): Likewise. + (gcc_jit_block_get_function): Likewise. + (gcc_jit_context_new_global): Likewise. + (gcc_jit_lvalue_as_object): Likewise. + (gcc_jit_lvalue_as_rvalue): Likewise. + (gcc_jit_rvalue_as_object): Likewise. + (gcc_jit_rvalue_get_type): Likewise. + (gcc_jit_context_new_rvalue_from_int): Likewise. + (gcc_jit_context_zero): Likewise. + (gcc_jit_context_one): Likewise. + (gcc_jit_context_new_rvalue_from_double): Likewise. + (gcc_jit_context_new_rvalue_from_ptr): Likewise. + (gcc_jit_context_null): Likewise. + (gcc_jit_context_new_string_literal): Likewise. + (gcc_jit_context_new_unary_op): Likewise. + (gcc_jit_context_new_binary_op): Likewise. + (gcc_jit_context_new_comparison): Likewise. + (gcc_jit_context_new_call): Likewise. + (gcc_jit_context_new_cast): Likewise. + (gcc_jit_context_new_array_access): Likewise. + (gcc_jit_object_get_context): Likewise. + (gcc_jit_object_get_debug_string): Likewise. + (gcc_jit_lvalue_access_field): Likewise. + (gcc_jit_rvalue_access_field): Likewise. + (gcc_jit_rvalue_dereference_field): Likewise. + (gcc_jit_rvalue_dereference_field): Likewise. + (gcc_jit_rvalue_dereference): Likewise. + (gcc_jit_lvalue_get_address): Likewise. + (gcc_jit_function_new_local): Likewise. + (gcc_jit_block_add_eval): Likewise. + (gcc_jit_block_add_assignment): Likewise. + (gcc_jit_block_add_assignment_op): Likewise. + (gcc_jit_block_end_with_conditional): Likewise. + (gcc_jit_block_add_comment): Likewise. + (gcc_jit_block_end_with_jump): Likewise. + (gcc_jit_block_end_with_return): Likewise. + (gcc_jit_block_end_with_void_return): Likewise. + (gcc_jit_context_set_str_option): Likewise. + (gcc_jit_context_set_int_option): Likewise. + (gcc_jit_context_set_bool_option): Likewise. + (gcc_jit_context_compile): Likewise. + (gcc_jit_context_dump_to_file): Likewise. + (gcc_jit_context_get_first_error): Likewise. + (gcc_jit_result_get_code): Likewise. + (gcc_jit_result_get_code): Likewise. + (gcc_jit_result_release): Likewise. + 2014-03-10 David Malcolm * libgccjit++.h (gccjit::context::new_rvalue): Make these diff --git a/gcc/jit/internal-api.c b/gcc/jit/internal-api.c index 17c8e9e..692dffb 100644 --- a/gcc/jit/internal-api.c +++ b/gcc/jit/internal-api.c @@ -530,7 +530,8 @@ recording::context::set_str_option (enum gcc_jit_str_option opt, { if (opt < 0 || opt >= GCC_JIT_NUM_STR_OPTIONS) { - add_error ("unrecognized (enum gcc_jit_str_option) value: %i", opt); + add_error (NULL, + "unrecognized (enum gcc_jit_str_option) value: %i", opt); return; } m_str_options[opt] = value; @@ -542,7 +543,8 @@ recording::context::set_int_option (enum gcc_jit_int_option opt, { if (opt < 0 || opt >= GCC_JIT_NUM_INT_OPTIONS) { - add_error ("unrecognized (enum gcc_jit_int_option) value: %i", opt); + add_error (NULL, + "unrecognized (enum gcc_jit_int_option) value: %i", opt); return; } m_int_options[opt] = value; @@ -554,7 +556,8 @@ recording::context::set_bool_option (enum gcc_jit_bool_option opt, { if (opt < 0 || opt >= GCC_JIT_NUM_BOOL_OPTIONS) { - add_error ("unrecognized (enum gcc_jit_bool_option) value: %i", opt); + add_error (NULL, + "unrecognized (enum gcc_jit_bool_option) value: %i", opt); return; } m_bool_options[opt] = value ? true : false; @@ -588,16 +591,16 @@ recording::context::compile () } void -recording::context::add_error (const char *fmt, ...) +recording::context::add_error (location *loc, const char *fmt, ...) { va_list ap; va_start (ap, fmt); - add_error_va (fmt, ap); + add_error_va (loc, fmt, ap); va_end (ap); } void -recording::context::add_error_va (const char *fmt, va_list ap) +recording::context::add_error_va (location *loc, const char *fmt, va_list ap) { char buf[1024]; vsnprintf (buf, sizeof (buf) - 1, fmt, ap); @@ -606,9 +609,15 @@ recording::context::add_error_va (const char *fmt, va_list ap) if (!progname) progname = "libgccjit.so"; - fprintf (stderr, "%s: %s\n", - progname, - buf); + if (loc) + fprintf (stderr, "%s: %s: error: %s\n", + progname, + loc->get_debug_string (), + buf); + else + fprintf (stderr, "%s: error: %s\n", + progname, + buf); if (!m_error_count) { @@ -760,7 +769,10 @@ recording::string::make_debug_string () void recording::location::replay_into (replayer *r) { - m_playback_obj = r->new_location (m_filename->c_str (), m_line, m_column); + m_playback_obj = r->new_location (this, + m_filename->c_str (), + m_line, + m_column); } recording::string * @@ -1375,7 +1387,8 @@ recording::function::validate () if (m_kind != GCC_JIT_FUNCTION_IMPORTED && m_return_type != m_ctxt->get_type (GCC_JIT_TYPE_VOID)) if (0 == m_blocks.length ()) - m_ctxt->add_error ("function %s returns non-void (type: %s)" + m_ctxt->add_error (m_loc, + "function %s returns non-void (type: %s)" " but has no blocks", get_debug_string (), m_return_type->get_debug_string ()); @@ -1431,7 +1444,8 @@ recording::function::validate () block *b; FOR_EACH_VEC_ELT (m_blocks, i, b) if (!b->m_is_reachable) - m_ctxt->add_error ("unreachable block: %s", + m_ctxt->add_error (b->get_loc (), + "unreachable block: %s", b->get_debug_string ()); } } @@ -1571,7 +1585,10 @@ recording::block::validate () { if (!has_been_terminated ()) { - m_func->get_context ()->add_error ("unterminated block in %s: %s", + statement *stmt = get_last_statement (); + location *loc = stmt ? stmt->get_loc () : NULL; + m_func->get_context ()->add_error (loc, + "unterminated block in %s: %s", m_func->get_debug_string (), get_debug_string ()); return false; @@ -1580,6 +1597,25 @@ recording::block::validate () return true; } +recording::location * +recording::block::get_loc () const +{ + recording::statement *stmt = get_first_statement (); + if (stmt) + return stmt->get_loc (); + else + return NULL; +} + +recording::statement * +recording::block::get_first_statement () const +{ + if (m_statements.length ()) + return m_statements[0]; + else + return NULL; +} + recording::statement * recording::block::get_last_statement () const { @@ -2339,7 +2375,8 @@ get_type (enum gcc_jit_types type_) tree type_node = get_tree_node_for_type (type_); if (NULL == type_node) { - add_error ("unrecognized (enum gcc_jit_types) value: %i", type_); + add_error (NULL, + "unrecognized (enum gcc_jit_types) value: %i", type_); return NULL; } @@ -2687,7 +2724,7 @@ new_unary_op (location *loc, switch (op) { default: - add_error ("unrecognized (enum gcc_jit_unary_op) value: %i", op); + add_error (loc, "unrecognized (enum gcc_jit_unary_op) value: %i", op); return NULL; case GCC_JIT_UNARY_OP_MINUS: @@ -2735,7 +2772,7 @@ new_binary_op (location *loc, switch (op) { default: - add_error ("unrecognized (enum gcc_jit_binary_op) value: %i", op); + add_error (loc, "unrecognized (enum gcc_jit_binary_op) value: %i", op); return NULL; case GCC_JIT_BINARY_OP_PLUS: @@ -2813,7 +2850,7 @@ new_comparison (location *loc, switch (op) { default: - add_error ("unrecognized (enum gcc_jit_comparison) value: %i", op); + add_error (loc, "unrecognized (enum gcc_jit_comparison) value: %i", op); return NULL; case GCC_JIT_COMPARISON_EQ: @@ -2887,7 +2924,9 @@ new_call (location *loc, } tree -playback::context::build_cast (tree expr, tree dst_type) +playback::context::build_cast (playback::location *loc, + playback::rvalue *expr, + playback::type *type_) { /* For comparison, see: - c/c-typeck.c:build_c_cast @@ -2895,38 +2934,40 @@ playback::context::build_cast (tree expr, tree dst_type) - convert.h Only some kinds of cast are currently supported here. */ - tree ret = NULL; - ret = targetm.convert_to_type (dst_type, expr); - if (ret) - return ret; - enum tree_code dst_code = TREE_CODE (dst_type); + tree t_expr = expr->as_tree (); + tree t_dst_type = type_->as_tree (); + tree t_ret = NULL; + t_ret = targetm.convert_to_type (t_dst_type, t_expr); + if (t_ret) + return t_ret; + enum tree_code dst_code = TREE_CODE (t_dst_type); switch (dst_code) { case INTEGER_TYPE: case ENUMERAL_TYPE: - ret = convert_to_integer (dst_type, expr); + t_ret = convert_to_integer (t_dst_type, t_expr); goto maybe_fold; case BOOLEAN_TYPE: /* Compare with c_objc_common_truthvalue_conversion and c_common_truthvalue_conversion. */ - /* For now, convert to: (expr != 0) */ - ret = build2 (NE_EXPR, dst_type, - expr, integer_zero_node); + /* For now, convert to: (t_expr != 0) */ + t_ret = build2 (NE_EXPR, t_dst_type, + t_expr, integer_zero_node); goto maybe_fold; case REAL_TYPE: - ret = convert_to_real (dst_type, expr); + t_ret = convert_to_real (t_dst_type, t_expr); goto maybe_fold; default: - add_error ("can't handle cast"); + add_error (loc, "can't handle cast"); return error_mark_node; maybe_fold: - if (TREE_CODE (ret) != C_MAYBE_CONST_EXPR) - ret = fold (ret); - return ret; + if (TREE_CODE (t_ret) != C_MAYBE_CONST_EXPR) + t_ret = fold (t_ret); + return t_ret; } } @@ -2937,8 +2978,7 @@ new_cast (playback::location *loc, playback::type *type_) { - tree t_cast = build_cast (expr->as_tree (), - type_->as_tree ()); + tree t_cast = build_cast (loc, expr, type_); if (loc) set_tree_location (t_cast, loc); return new rvalue (this, t_cast); @@ -3486,7 +3526,8 @@ compile () switch (get_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL)) { default: - add_error ("unrecognized optimization level: %i", + add_error (NULL, + "unrecognized optimization level: %i", get_int_option (GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL)); return NULL; @@ -3786,19 +3827,21 @@ handle_locations () void playback::context:: -add_error (const char *fmt, ...) +add_error (location *loc, const char *fmt, ...) { va_list ap; va_start (ap, fmt); - m_recording_ctxt->add_error_va (fmt, ap); + m_recording_ctxt->add_error_va (loc ? loc->get_recording_loc () : NULL, + fmt, ap); va_end (ap); } void playback::context:: -add_error_va (const char *fmt, va_list ap) +add_error_va (location *loc, const char *fmt, va_list ap) { - m_recording_ctxt->add_error_va (fmt, ap); + m_recording_ctxt->add_error_va (loc ? loc->get_recording_loc () : NULL, + fmt, ap); } result:: @@ -3835,7 +3878,8 @@ get_code (const char *funcname) playback::location * playback::context:: -new_location (const char *filename, +new_location (recording::location *rloc, + const char *filename, int line, int column) { @@ -3844,7 +3888,7 @@ new_location (const char *filename, /* Likewise for the line within the file. */ source_line *src_line = src_file->get_source_line (line); /* Likewise for the column within the line. */ - location *loc = src_line->get_location (column); + location *loc = src_line->get_location (rloc, column); return loc; } @@ -3913,7 +3957,7 @@ playback::source_line::source_line (source_file *file, int line_num) : playback::location * playback::source_line:: -get_location (int column_num) +get_location (recording::location *rloc, int column_num) { int i; location *loc; @@ -3924,13 +3968,16 @@ get_location (int column_num) return loc; /* Not found. */ - loc = new location (this, column_num); + loc = new location (rloc, this, column_num); m_locations.safe_push (loc); return loc; } -playback::location::location (source_line *line, int column_num) : +playback::location::location (recording::location *loc, + source_line *line, + int column_num) : m_srcloc (UNKNOWN_LOCATION), + m_recording_loc (loc), m_line (line), m_column_num(column_num) { diff --git a/gcc/jit/internal-api.h b/gcc/jit/internal-api.h index 23352fc..5048f41 100644 --- a/gcc/jit/internal-api.h +++ b/gcc/jit/internal-api.h @@ -296,18 +296,21 @@ public: compile (); void - add_error (const char *fmt, ...) - GNU_PRINTF(2, 3); + add_error (location *loc, const char *fmt, ...) + GNU_PRINTF(3, 4); void - add_error_va (const char *fmt, va_list ap) - GNU_PRINTF(2, 0); + add_error_va (location *loc, const char *fmt, va_list ap) + GNU_PRINTF(3, 0); const char * get_first_error () const; bool errors_occurred () const { + if (m_parent_ctxt) + if (m_parent_ctxt->errors_occurred ()) + return true; return m_error_count; } @@ -968,6 +971,9 @@ public: bool validate (); + location *get_loc () const; + + statement *get_first_statement () const; statement *get_last_statement () const; int get_successor_blocks (block **next1, block **next2) const; @@ -1351,6 +1357,8 @@ public: void write_to_dump (dump &d); + location *get_loc () const { return m_loc; } + protected: statement (block *b, location *loc) : memento (b->m_ctxt), @@ -1554,7 +1562,8 @@ public: void replay (); location * - new_location (const char *filename, + new_location (recording::location *rloc, + const char *filename, int line, int column); @@ -1680,12 +1689,12 @@ public: compile (); void - add_error (const char *fmt, ...) - GNU_PRINTF(2, 3); + add_error (location *loc, const char *fmt, ...) + GNU_PRINTF(3, 4); void - add_error_va (const char *fmt, va_list ap) - GNU_PRINTF(2, 0); + add_error_va (location *loc, const char *fmt, va_list ap) + GNU_PRINTF(3, 0); const char * get_first_error () const; @@ -1713,7 +1722,9 @@ private: void dump_generated_code (); tree - build_cast (tree expr, tree dst_type); + build_cast (location *loc, + rvalue *expr, + type *type_); source_file * get_source_file (const char *filename); @@ -2016,7 +2027,7 @@ public: source_line (source_file *file, int line_num); location * - get_location (int column_num); + get_location (recording::location *rloc, int column_num); int get_line_num () const { return m_line_num; } @@ -2032,13 +2043,16 @@ private: class location : public wrapper { public: - location (source_line *line, int column_num); + location (recording::location *loc, source_line *line, int column_num); int get_column_num () const { return m_column_num; } + recording::location *get_recording_loc () const { return m_recording_loc; } + source_location m_srcloc; private: + recording::location *m_recording_loc; source_line *m_line; int m_column_num; }; diff --git a/gcc/jit/jit-builtins.c b/gcc/jit/jit-builtins.c index afc773d..160ef20 100644 --- a/gcc/jit/jit-builtins.c +++ b/gcc/jit/jit-builtins.c @@ -137,7 +137,7 @@ builtins_manager::get_builtin_function (const char *name) enum built_in_function builtin_id; if (!find_builtin_by_name (name, &builtin_id)) { - m_ctxt->add_error ("builtin \"%s\" not found", name); + m_ctxt->add_error (NULL, "builtin \"%s\" not found", name); return NULL; } @@ -283,7 +283,8 @@ builtins_manager::make_primitive_type (enum jit_builtin_type type_id) { default: // only some of these types are implemented so far: - m_ctxt->add_error ("unimplemented primitive type for builtin: %d", type_id); + m_ctxt->add_error (NULL, + "unimplemented primitive type for builtin: %d", type_id); return NULL; case BT_VOID: return m_ctxt->get_type (GCC_JIT_TYPE_VOID); diff --git a/gcc/jit/libgccjit.c b/gcc/jit/libgccjit.c index 817d1b5..936576c 100644 --- a/gcc/jit/libgccjit.c +++ b/gcc/jit/libgccjit.c @@ -84,117 +84,117 @@ struct gcc_jit_param : public gcc::jit::recording::param /* TODO: mark failure branches as unlikely? */ -#define RETURN_VAL_IF_FAIL(TEST_EXPR, RETURN_EXPR, CTXT, ERR_MSG) \ +#define RETURN_VAL_IF_FAIL(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_MSG) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: %s", __func__, (ERR_MSG)); \ + jit_error ((CTXT), (LOC), "%s: %s", __func__, (ERR_MSG)); \ return (RETURN_EXPR); \ } \ JIT_END_STMT -#define RETURN_VAL_IF_FAIL_PRINTF1(TEST_EXPR, RETURN_EXPR, CTXT, ERR_FMT, A0) \ +#define RETURN_VAL_IF_FAIL_PRINTF1(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0)); \ return (RETURN_EXPR); \ } \ JIT_END_STMT -#define RETURN_VAL_IF_FAIL_PRINTF2(TEST_EXPR, RETURN_EXPR, CTXT, ERR_FMT, A0, A1) \ +#define RETURN_VAL_IF_FAIL_PRINTF2(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0), (A1)); \ return (RETURN_EXPR); \ } \ JIT_END_STMT -#define RETURN_VAL_IF_FAIL_PRINTF3(TEST_EXPR, RETURN_EXPR, CTXT, ERR_FMT, A0, A1, A2) \ +#define RETURN_VAL_IF_FAIL_PRINTF3(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0), (A1), (A2)); \ return (RETURN_EXPR); \ } \ JIT_END_STMT -#define RETURN_VAL_IF_FAIL_PRINTF4(TEST_EXPR, RETURN_EXPR, CTXT, ERR_FMT, A0, A1, A2, A3) \ +#define RETURN_VAL_IF_FAIL_PRINTF4(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0), (A1), (A2), (A3)); \ return (RETURN_EXPR); \ } \ JIT_END_STMT -#define RETURN_VAL_IF_FAIL_PRINTF6(TEST_EXPR, RETURN_EXPR, CTXT, ERR_FMT, A0, A1, A2, A3, A4, A5) \ +#define RETURN_VAL_IF_FAIL_PRINTF6(TEST_EXPR, RETURN_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4, A5) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0), (A1), (A2), (A3), (A4), (A5)); \ return (RETURN_EXPR); \ } \ JIT_END_STMT -#define RETURN_NULL_IF_FAIL(TEST_EXPR, CTXT, ERR_MSG) \ - RETURN_VAL_IF_FAIL ((TEST_EXPR), NULL, (CTXT), (ERR_MSG)) +#define RETURN_NULL_IF_FAIL(TEST_EXPR, CTXT, LOC, ERR_MSG) \ + RETURN_VAL_IF_FAIL ((TEST_EXPR), NULL, (CTXT), (LOC), (ERR_MSG)) -#define RETURN_NULL_IF_FAIL_PRINTF1(TEST_EXPR, CTXT, ERR_FMT, A0) \ - RETURN_VAL_IF_FAIL_PRINTF1 (TEST_EXPR, NULL, CTXT, ERR_FMT, A0) +#define RETURN_NULL_IF_FAIL_PRINTF1(TEST_EXPR, CTXT, LOC, ERR_FMT, A0) \ + RETURN_VAL_IF_FAIL_PRINTF1 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0) -#define RETURN_NULL_IF_FAIL_PRINTF2(TEST_EXPR, CTXT, ERR_FMT, A0, A1) \ - RETURN_VAL_IF_FAIL_PRINTF2 (TEST_EXPR, NULL, CTXT, ERR_FMT, A0, A1) +#define RETURN_NULL_IF_FAIL_PRINTF2(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1) \ + RETURN_VAL_IF_FAIL_PRINTF2 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1) -#define RETURN_NULL_IF_FAIL_PRINTF3(TEST_EXPR, CTXT, ERR_FMT, A0, A1, A2) \ - RETURN_VAL_IF_FAIL_PRINTF3 (TEST_EXPR, NULL, CTXT, ERR_FMT, A0, A1, A2) +#define RETURN_NULL_IF_FAIL_PRINTF3(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2) \ + RETURN_VAL_IF_FAIL_PRINTF3 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2) -#define RETURN_NULL_IF_FAIL_PRINTF4(TEST_EXPR, CTXT, ERR_FMT, A0, A1, A2, A3) \ - RETURN_VAL_IF_FAIL_PRINTF4 (TEST_EXPR, NULL, CTXT, ERR_FMT, A0, A1, A2, A3) +#define RETURN_NULL_IF_FAIL_PRINTF4(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) \ + RETURN_VAL_IF_FAIL_PRINTF4 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) -#define RETURN_NULL_IF_FAIL_PRINTF6(TEST_EXPR, CTXT, ERR_FMT, A0, A1, A2, A3, A4, A5) \ - RETURN_VAL_IF_FAIL_PRINTF6 (TEST_EXPR, NULL, CTXT, ERR_FMT, A0, A1, A2, A3, A4, A5) +#define RETURN_NULL_IF_FAIL_PRINTF6(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4, A5) \ + RETURN_VAL_IF_FAIL_PRINTF6 (TEST_EXPR, NULL, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, A4, A5) -#define RETURN_IF_FAIL(TEST_EXPR, CTXT, ERR_MSG) \ +#define RETURN_IF_FAIL(TEST_EXPR, CTXT, LOC, ERR_MSG) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: %s", __func__, (ERR_MSG)); \ + jit_error ((CTXT), (LOC), "%s: %s", __func__, (ERR_MSG)); \ return; \ } \ JIT_END_STMT -#define RETURN_IF_FAIL_PRINTF1(TEST_EXPR, CTXT, ERR_FMT, A0) \ +#define RETURN_IF_FAIL_PRINTF1(TEST_EXPR, CTXT, LOC, ERR_FMT, A0) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0)); \ return; \ } \ JIT_END_STMT -#define RETURN_IF_FAIL_PRINTF2(TEST_EXPR, CTXT, ERR_FMT, A0, A1) \ +#define RETURN_IF_FAIL_PRINTF2(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0), (A1)); \ return; \ } \ JIT_END_STMT -#define RETURN_IF_FAIL_PRINTF4(TEST_EXPR, CTXT, ERR_FMT, A0, A1, A2, A3) \ +#define RETURN_IF_FAIL_PRINTF4(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3) \ JIT_BEGIN_STMT \ if (!(TEST_EXPR)) \ { \ - jit_error ((CTXT), "%s: " ERR_FMT, \ + jit_error ((CTXT), (LOC), "%s: " ERR_FMT, \ __func__, (A0), (A1), (A2), (A3)); \ return; \ } \ @@ -202,40 +202,46 @@ struct gcc_jit_param : public gcc::jit::recording::param /* Check that BLOCK is non-NULL, and that it's OK to add statements to it. */ -#define RETURN_IF_NOT_VALID_BLOCK(BLOCK) \ +#define RETURN_IF_NOT_VALID_BLOCK(BLOCK, LOC) \ JIT_BEGIN_STMT \ - RETURN_IF_FAIL ((BLOCK), NULL, "NULL block"); \ + RETURN_IF_FAIL ((BLOCK), NULL, (LOC), "NULL block"); \ RETURN_IF_FAIL_PRINTF2 ( \ !(BLOCK)->has_been_terminated (), \ (BLOCK)->get_context (), \ + (LOC), \ "adding to terminated block: %s (already terminated by: %s)", \ (BLOCK)->get_debug_string (), \ (BLOCK)->get_last_statement ()->get_debug_string ()); \ JIT_END_STMT -#define RETURN_NULL_IF_NOT_VALID_BLOCK(BLOCK) \ +#define RETURN_NULL_IF_NOT_VALID_BLOCK(BLOCK, LOC) \ JIT_BEGIN_STMT \ - RETURN_NULL_IF_FAIL ((BLOCK), NULL, "NULL block"); \ + RETURN_NULL_IF_FAIL ((BLOCK), NULL, (LOC), "NULL block"); \ RETURN_NULL_IF_FAIL_PRINTF2 ( \ !(BLOCK)->has_been_terminated (), \ (BLOCK)->get_context (), \ + (LOC), \ "adding to terminated block: %s (already terminated by: %s)", \ (BLOCK)->get_debug_string (), \ (BLOCK)->get_last_statement ()->get_debug_string ()); \ JIT_END_STMT static void -jit_error (gcc::jit::recording::context *ctxt, const char *fmt, ...) - GNU_PRINTF(2, 3); +jit_error (gcc::jit::recording::context *ctxt, + gcc_jit_location *loc, + const char *fmt, ...) + GNU_PRINTF(3, 4); static void -jit_error (gcc::jit::recording::context *ctxt, const char *fmt, ...) +jit_error (gcc::jit::recording::context *ctxt, + gcc_jit_location *loc, + const char *fmt, ...) { va_list ap; va_start (ap, fmt); if (ctxt) - ctxt->add_error_va (fmt, ap); + ctxt->add_error_va (loc, fmt, ap); else { /* No context? Send to stderr. */ @@ -277,7 +283,7 @@ gcc_jit_context_new_location (gcc_jit_context *ctxt, int line, int column) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); return (gcc_jit_location *)ctxt->new_location (filename, line, column); } @@ -285,7 +291,7 @@ gcc_jit_context_new_location (gcc_jit_context *ctxt, gcc_jit_object * gcc_jit_location_as_object (gcc_jit_location *loc) { - RETURN_NULL_IF_FAIL (loc, NULL, "NULL location"); + RETURN_NULL_IF_FAIL (loc, NULL, NULL, "NULL location"); return static_cast (loc->as_object ()); } @@ -293,7 +299,7 @@ gcc_jit_location_as_object (gcc_jit_location *loc) gcc_jit_object * gcc_jit_type_as_object (gcc_jit_type *type) { - RETURN_NULL_IF_FAIL (type, NULL, "NULL type"); + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); return static_cast (type->as_object ()); } @@ -302,7 +308,7 @@ gcc_jit_type * gcc_jit_context_get_type (gcc_jit_context *ctxt, enum gcc_jit_types type) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); /* The inner function checks "type" for us. */ return (gcc_jit_type *)ctxt->get_type (type); @@ -312,8 +318,8 @@ gcc_jit_type * gcc_jit_context_get_int_type (gcc_jit_context *ctxt, int num_bytes, int is_signed) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (num_bytes >= 0, ctxt, "negative size"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (num_bytes >= 0, ctxt, NULL, "negative size"); return (gcc_jit_type *)ctxt->get_int_type (num_bytes, is_signed); } @@ -321,7 +327,7 @@ gcc_jit_context_get_int_type (gcc_jit_context *ctxt, gcc_jit_type * gcc_jit_type_get_pointer (gcc_jit_type *type) { - RETURN_NULL_IF_FAIL (type, NULL, "NULL type"); + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); return (gcc_jit_type *)type->get_pointer (); } @@ -329,7 +335,7 @@ gcc_jit_type_get_pointer (gcc_jit_type *type) gcc_jit_type * gcc_jit_type_get_const (gcc_jit_type *type) { - RETURN_NULL_IF_FAIL (type, NULL, "NULL type"); + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); return (gcc_jit_type *)type->get_const (); } @@ -337,7 +343,7 @@ gcc_jit_type_get_const (gcc_jit_type *type) gcc_jit_type * gcc_jit_type_get_volatile (gcc_jit_type *type) { - RETURN_NULL_IF_FAIL (type, NULL, "NULL type"); + RETURN_NULL_IF_FAIL (type, NULL, NULL, "NULL type"); return (gcc_jit_type *)type->get_volatile (); } @@ -348,8 +354,8 @@ gcc_jit_context_new_array_type (gcc_jit_context *ctxt, gcc_jit_type *element_type, int num_elements) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (element_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (element_type, ctxt, loc, "NULL type"); return (gcc_jit_type *)ctxt->new_array_type (loc, element_type, @@ -362,9 +368,9 @@ gcc_jit_context_new_field (gcc_jit_context *ctxt, gcc_jit_type *type, const char *name) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (type, ctxt, "NULL type"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); return (gcc_jit_field *)ctxt->new_field (loc, type, name); } @@ -372,7 +378,7 @@ gcc_jit_context_new_field (gcc_jit_context *ctxt, gcc_jit_object * gcc_jit_field_as_object (gcc_jit_field *field) { - RETURN_NULL_IF_FAIL (field, NULL, "NULL field"); + RETURN_NULL_IF_FAIL (field, NULL, NULL, "NULL field"); return static_cast (field->as_object ()); } @@ -384,16 +390,16 @@ gcc_jit_context_new_struct_type (gcc_jit_context *ctxt, int num_fields, gcc_jit_field **fields) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); if (num_fields) - RETURN_NULL_IF_FAIL (fields, ctxt, "NULL fields ptr"); + RETURN_NULL_IF_FAIL (fields, ctxt, loc, "NULL fields ptr"); for (int i = 0; i < num_fields; i++) { - RETURN_NULL_IF_FAIL (fields[i], ctxt, "NULL field ptr"); + RETURN_NULL_IF_FAIL (fields[i], ctxt, loc, "NULL field ptr"); RETURN_NULL_IF_FAIL_PRINTF2 ( NULL == fields[i]->get_container (), - ctxt, + ctxt, loc, "%s is already a field of %s", fields[i]->get_debug_string (), fields[i]->get_container ()->get_debug_string ()); @@ -412,8 +418,8 @@ gcc_jit_context_new_opaque_struct (gcc_jit_context *ctxt, gcc_jit_location *loc, const char *name) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); return (gcc_jit_struct *)ctxt->new_struct_type (loc, name); } @@ -421,7 +427,7 @@ gcc_jit_context_new_opaque_struct (gcc_jit_context *ctxt, gcc_jit_type * gcc_jit_struct_as_type (gcc_jit_struct *struct_type) { - RETURN_NULL_IF_FAIL (struct_type, NULL, "NULL struct_type"); + RETURN_NULL_IF_FAIL (struct_type, NULL, NULL, "NULL struct_type"); return static_cast (struct_type->as_type ()); } @@ -432,20 +438,20 @@ gcc_jit_struct_set_fields (gcc_jit_struct *struct_type, int num_fields, gcc_jit_field **fields) { - RETURN_IF_FAIL (struct_type, NULL, "NULL struct_type"); + RETURN_IF_FAIL (struct_type, NULL, loc, "NULL struct_type"); gcc::jit::recording::context *ctxt = struct_type->m_ctxt; RETURN_IF_FAIL_PRINTF1 ( - NULL == struct_type->get_fields (), ctxt, + NULL == struct_type->get_fields (), ctxt, loc, "%s already has had fields set", struct_type->get_debug_string ()); if (num_fields) - RETURN_IF_FAIL (fields, ctxt, "NULL fields ptr"); + RETURN_IF_FAIL (fields, ctxt, loc, "NULL fields ptr"); for (int i = 0; i < num_fields; i++) { - RETURN_IF_FAIL (fields[i], ctxt, "NULL field ptr"); + RETURN_IF_FAIL (fields[i], ctxt, loc, "NULL field ptr"); RETURN_IF_FAIL_PRINTF2 ( NULL == fields[i]->get_container (), - ctxt, + ctxt, loc, "%s is already a field of %s", fields[i]->get_debug_string (), fields[i]->get_container ()->get_debug_string ()); @@ -462,9 +468,9 @@ gcc_jit_context_new_param (gcc_jit_context *ctxt, gcc_jit_type *type, const char *name) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (type, ctxt, "NULL type"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); return (gcc_jit_param *)ctxt->new_param (loc, type, name); } @@ -472,7 +478,7 @@ gcc_jit_context_new_param (gcc_jit_context *ctxt, gcc_jit_object * gcc_jit_param_as_object (gcc_jit_param *param) { - RETURN_NULL_IF_FAIL (param, NULL, "NULL param"); + RETURN_NULL_IF_FAIL (param, NULL, NULL, "NULL param"); return static_cast (param->as_object ()); } @@ -480,7 +486,7 @@ gcc_jit_param_as_object (gcc_jit_param *param) gcc_jit_lvalue * gcc_jit_param_as_lvalue (gcc_jit_param *param) { - RETURN_NULL_IF_FAIL (param, NULL, "NULL param"); + RETURN_NULL_IF_FAIL (param, NULL, NULL, "NULL param"); return (gcc_jit_lvalue *)param->as_lvalue (); } @@ -488,7 +494,7 @@ gcc_jit_param_as_lvalue (gcc_jit_param *param) gcc_jit_rvalue * gcc_jit_param_as_rvalue (gcc_jit_param *param) { - RETURN_NULL_IF_FAIL (param, NULL, "NULL param"); + RETURN_NULL_IF_FAIL (param, NULL, NULL, "NULL param"); return (gcc_jit_rvalue *)param->as_rvalue (); } @@ -503,9 +509,9 @@ gcc_jit_context_new_function (gcc_jit_context *ctxt, gcc_jit_param **params, int is_variadic) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (return_type, ctxt, "NULL return_type"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (return_type, ctxt, loc, "NULL return_type"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); /* The assembler can only handle certain names, so for now, enforce C's rules for identiers upon the name. Eventually we'll need some way to interact with e.g. C++ name mangling. */ @@ -514,7 +520,7 @@ gcc_jit_context_new_function (gcc_jit_context *ctxt, char ch = *name; RETURN_NULL_IF_FAIL_PRINTF2 ( IS_ASCII_ALPHA (ch) || ch == '_', - ctxt, + ctxt, loc, "name \"%s\" contains invalid character: '%c'", name, ch); /* Subsequent chars: */ @@ -522,18 +528,20 @@ gcc_jit_context_new_function (gcc_jit_context *ctxt, { RETURN_NULL_IF_FAIL_PRINTF2 ( IS_ASCII_ALNUM (ch) || ch == '_', - ctxt, + ctxt, loc, "name \"%s\" contains invalid character: '%c'", name, ch); } } - RETURN_NULL_IF_FAIL ((num_params == 0) || params, ctxt, "NULL params"); + RETURN_NULL_IF_FAIL_PRINTF1 ( + (num_params == 0) || params, + ctxt, loc, + "NULL params creating function %s", name); for (int i = 0; i < num_params; i++) - if (!params[i]) - { - jit_error (ctxt, "%s: NULL parameter %i", __func__, i); - return NULL; - } + RETURN_NULL_IF_FAIL_PRINTF2 ( + params[i], + ctxt, loc, + "NULL parameter %i creating function %s", i, name); return (gcc_jit_function*) ctxt->new_function (loc, kind, return_type, name, @@ -547,8 +555,8 @@ gcc_jit_function * gcc_jit_context_get_builtin_function (gcc_jit_context *ctxt, const char *name) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (name, ctxt, NULL, "NULL name"); return static_cast (ctxt->get_builtin_function (name)); } @@ -556,7 +564,7 @@ gcc_jit_context_get_builtin_function (gcc_jit_context *ctxt, gcc_jit_object * gcc_jit_function_as_object (gcc_jit_function *func) { - RETURN_NULL_IF_FAIL (func, NULL, "NULL function"); + RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function"); return static_cast (func->as_object ()); } @@ -564,12 +572,12 @@ gcc_jit_function_as_object (gcc_jit_function *func) gcc_jit_param * gcc_jit_function_get_param (gcc_jit_function *func, int index) { - RETURN_NULL_IF_FAIL (func, NULL, "NULL function"); + RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function"); gcc::jit::recording::context *ctxt = func->m_ctxt; - RETURN_NULL_IF_FAIL (index >= 0, ctxt, "negative index"); + RETURN_NULL_IF_FAIL (index >= 0, ctxt, NULL, "negative index"); int num_params = func->get_params ().length (); RETURN_NULL_IF_FAIL_PRINTF3 (index < num_params, - ctxt, + ctxt, NULL, "index of %d is too large (%s has %d params)", index, func->get_debug_string (), @@ -582,9 +590,9 @@ void gcc_jit_function_dump_to_dot (gcc_jit_function *func, const char *path) { - RETURN_IF_FAIL (func, NULL, "NULL function"); + RETURN_IF_FAIL (func, NULL, NULL, "NULL function"); gcc::jit::recording::context *ctxt = func->m_ctxt; - RETURN_IF_FAIL (path, ctxt, "NULL path"); + RETURN_IF_FAIL (path, ctxt, NULL, "NULL path"); func->dump_to_dot (path); } @@ -593,9 +601,9 @@ gcc_jit_block* gcc_jit_function_new_block (gcc_jit_function *func, const char *name) { - RETURN_NULL_IF_FAIL (func, NULL, "NULL function"); + RETURN_NULL_IF_FAIL (func, NULL, NULL, "NULL function"); RETURN_NULL_IF_FAIL (func->get_kind () != GCC_JIT_FUNCTION_IMPORTED, - func->get_context (), + func->get_context (), NULL, "cannot add block to an imported function"); /* name can be NULL. */ @@ -605,7 +613,7 @@ gcc_jit_function_new_block (gcc_jit_function *func, gcc_jit_object * gcc_jit_block_as_object (gcc_jit_block *block) { - RETURN_NULL_IF_FAIL (block, NULL, "NULL block"); + RETURN_NULL_IF_FAIL (block, NULL, NULL, "NULL block"); return static_cast (block->as_object ()); } @@ -613,7 +621,7 @@ gcc_jit_block_as_object (gcc_jit_block *block) gcc_jit_function * gcc_jit_block_get_function (gcc_jit_block *block) { - RETURN_NULL_IF_FAIL (block, NULL, "NULL block"); + RETURN_NULL_IF_FAIL (block, NULL, NULL, "NULL block"); return static_cast (block->get_function ()); } @@ -624,9 +632,9 @@ gcc_jit_context_new_global (gcc_jit_context *ctxt, gcc_jit_type *type, const char *name) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (type, ctxt, "NULL type"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); return (gcc_jit_lvalue *)ctxt->new_global (loc, type, name); } @@ -634,7 +642,7 @@ gcc_jit_context_new_global (gcc_jit_context *ctxt, gcc_jit_object * gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue) { - RETURN_NULL_IF_FAIL (lvalue, NULL, "NULL lvalue"); + RETURN_NULL_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue"); return static_cast (lvalue->as_object ()); } @@ -642,7 +650,7 @@ gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue) gcc_jit_rvalue * gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue *lvalue) { - RETURN_NULL_IF_FAIL (lvalue, NULL, "NULL lvalue"); + RETURN_NULL_IF_FAIL (lvalue, NULL, NULL, "NULL lvalue"); return (gcc_jit_rvalue *)lvalue->as_rvalue (); } @@ -650,7 +658,7 @@ gcc_jit_lvalue_as_rvalue (gcc_jit_lvalue *lvalue) gcc_jit_object * gcc_jit_rvalue_as_object (gcc_jit_rvalue *rvalue) { - RETURN_NULL_IF_FAIL (rvalue, NULL, "NULL rvalue"); + RETURN_NULL_IF_FAIL (rvalue, NULL, NULL, "NULL rvalue"); return static_cast (rvalue->as_object ()); } @@ -658,7 +666,7 @@ gcc_jit_rvalue_as_object (gcc_jit_rvalue *rvalue) gcc_jit_type * gcc_jit_rvalue_get_type (gcc_jit_rvalue *rvalue) { - RETURN_NULL_IF_FAIL (rvalue, NULL, "NULL rvalue"); + RETURN_NULL_IF_FAIL (rvalue, NULL, NULL, "NULL rvalue"); return static_cast (rvalue->get_type ()); } @@ -668,8 +676,8 @@ gcc_jit_context_new_rvalue_from_int (gcc_jit_context *ctxt, gcc_jit_type *numeric_type, int value) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (numeric_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (numeric_type, ctxt, NULL, "NULL type"); return (gcc_jit_rvalue *)ctxt->new_rvalue_from_int (numeric_type, value); } @@ -678,8 +686,8 @@ gcc_jit_rvalue * gcc_jit_context_zero (gcc_jit_context *ctxt, gcc_jit_type *numeric_type) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (numeric_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (numeric_type, ctxt, NULL, "NULL type"); return gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 0); } @@ -688,8 +696,8 @@ gcc_jit_rvalue * gcc_jit_context_one (gcc_jit_context *ctxt, gcc_jit_type *numeric_type) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (numeric_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (numeric_type, ctxt, NULL, "NULL type"); return gcc_jit_context_new_rvalue_from_int (ctxt, numeric_type, 1); } @@ -699,8 +707,8 @@ gcc_jit_context_new_rvalue_from_double (gcc_jit_context *ctxt, gcc_jit_type *numeric_type, double value) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (numeric_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (numeric_type, ctxt, NULL, "NULL type"); return (gcc_jit_rvalue *)ctxt->new_rvalue_from_double (numeric_type, value); } @@ -710,10 +718,11 @@ gcc_jit_context_new_rvalue_from_ptr (gcc_jit_context *ctxt, gcc_jit_type *pointer_type, void *value) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (pointer_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (pointer_type, ctxt, NULL, "NULL type"); RETURN_NULL_IF_FAIL_PRINTF1 ( - pointer_type->dereference (), ctxt, + pointer_type->dereference (), + ctxt, NULL, "not a pointer type (type: %s)", pointer_type->get_debug_string ()); @@ -724,10 +733,11 @@ gcc_jit_rvalue * gcc_jit_context_null (gcc_jit_context *ctxt, gcc_jit_type *pointer_type) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (pointer_type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (pointer_type, ctxt, NULL, "NULL type"); RETURN_NULL_IF_FAIL_PRINTF1 ( - pointer_type->dereference (), ctxt, + pointer_type->dereference (), + ctxt, NULL, "not a pointer type (type: %s)", pointer_type->get_debug_string ()); @@ -738,8 +748,8 @@ gcc_jit_rvalue * gcc_jit_context_new_string_literal (gcc_jit_context *ctxt, const char *value) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (value, ctxt, "NULL value"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (value, ctxt, NULL, "NULL value"); return (gcc_jit_rvalue *)ctxt->new_string_literal (value); } @@ -751,10 +761,10 @@ gcc_jit_context_new_unary_op (gcc_jit_context *ctxt, gcc_jit_type *result_type, gcc_jit_rvalue *rvalue) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); /* op is checked by the inner function. */ - RETURN_NULL_IF_FAIL (result_type, ctxt, "NULL result_type"); - RETURN_NULL_IF_FAIL (rvalue, ctxt, "NULL rvalue"); + RETURN_NULL_IF_FAIL (result_type, ctxt, loc, "NULL result_type"); + RETURN_NULL_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); return (gcc_jit_rvalue *)ctxt->new_unary_op (loc, op, result_type, rvalue); } @@ -766,14 +776,14 @@ gcc_jit_context_new_binary_op (gcc_jit_context *ctxt, gcc_jit_type *result_type, gcc_jit_rvalue *a, gcc_jit_rvalue *b) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); /* op is checked by the inner function. */ - RETURN_NULL_IF_FAIL (result_type, ctxt, "NULL result_type"); - RETURN_NULL_IF_FAIL (a, ctxt, "NULL a"); - RETURN_NULL_IF_FAIL (b, ctxt, "NULL b"); + RETURN_NULL_IF_FAIL (result_type, ctxt, loc, "NULL result_type"); + RETURN_NULL_IF_FAIL (a, ctxt, loc, "NULL a"); + RETURN_NULL_IF_FAIL (b, ctxt, loc, "NULL b"); RETURN_NULL_IF_FAIL_PRINTF4 ( a->get_type () == b->get_type (), - ctxt, + ctxt, loc, "mismatching types for binary op:" " a: %s (type: %s) b: %s (type: %s)", a->get_debug_string (), @@ -790,13 +800,13 @@ gcc_jit_context_new_comparison (gcc_jit_context *ctxt, enum gcc_jit_comparison op, gcc_jit_rvalue *a, gcc_jit_rvalue *b) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); /* op is checked by the inner function. */ - RETURN_NULL_IF_FAIL (a, ctxt, "NULL a"); - RETURN_NULL_IF_FAIL (b, ctxt, "NULL b"); + RETURN_NULL_IF_FAIL (a, ctxt, loc, "NULL a"); + RETURN_NULL_IF_FAIL (b, ctxt, loc, "NULL b"); RETURN_NULL_IF_FAIL_PRINTF4 ( a->get_type ()->unqualified () == b->get_type ()->unqualified (), - ctxt, + ctxt, loc, "mismatching types for comparison:" " a: %s (type: %s) b: %s (type: %s)", a->get_debug_string (), @@ -813,17 +823,17 @@ gcc_jit_context_new_call (gcc_jit_context *ctxt, gcc_jit_function *func, int numargs , gcc_jit_rvalue **args) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (func, ctxt, "NULL function"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (func, ctxt, loc, "NULL function"); if (numargs) - RETURN_NULL_IF_FAIL (args, ctxt, "NULL args"); + RETURN_NULL_IF_FAIL (args, ctxt, loc, "NULL args"); int min_num_params = func->get_params ().length (); bool is_variadic = func->is_variadic (); RETURN_NULL_IF_FAIL_PRINTF3 ( numargs >= min_num_params, - ctxt, + ctxt, loc, "not enough arguments to function \"%s\"" " (got %i args, expected %i)", func->get_name ()->c_str (), @@ -831,7 +841,7 @@ gcc_jit_context_new_call (gcc_jit_context *ctxt, RETURN_NULL_IF_FAIL_PRINTF3 ( (numargs == min_num_params || is_variadic), - ctxt, + ctxt, loc, "too many arguments to function \"%s\"" " (got %i args, expected %i)", func->get_name ()->c_str (), @@ -844,7 +854,7 @@ gcc_jit_context_new_call (gcc_jit_context *ctxt, RETURN_NULL_IF_FAIL_PRINTF4 ( arg, - ctxt, + ctxt, loc, "NULL argument %i to function \"%s\":" " param %s (type: %s)", i + 1, @@ -855,7 +865,7 @@ gcc_jit_context_new_call (gcc_jit_context *ctxt, RETURN_NULL_IF_FAIL_PRINTF6 ( compatible_types (param->get_type (), arg->get_type ()), - ctxt, + ctxt, loc, "mismatching types for argument %d of function \"%s\":" " assignment to param %s (type: %s) from %s (type: %s)", i + 1, @@ -878,9 +888,9 @@ gcc_jit_context_new_cast (gcc_jit_context *ctxt, gcc_jit_rvalue *rvalue, gcc_jit_type *type) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (rvalue, ctxt, "NULL rvalue"); - RETURN_NULL_IF_FAIL (type, ctxt, "NULL type"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); + RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type"); return static_cast (ctxt->new_cast (loc, rvalue, type)); } @@ -891,11 +901,12 @@ gcc_jit_context_new_array_access (gcc_jit_context *ctxt, gcc_jit_rvalue *ptr, gcc_jit_rvalue *index) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_NULL_IF_FAIL (ptr, ctxt, "NULL ptr"); - RETURN_NULL_IF_FAIL (index, ctxt, "NULL index"); + RETURN_NULL_IF_FAIL (ctxt, NULL, loc, "NULL context"); + RETURN_NULL_IF_FAIL (ptr, ctxt, loc, "NULL ptr"); + RETURN_NULL_IF_FAIL (index, ctxt, loc, "NULL index"); RETURN_NULL_IF_FAIL_PRINTF2 ( - ptr->get_type ()->dereference (), ctxt, + ptr->get_type ()->dereference (), + ctxt, loc, "%s (type: %s) is not a pointer", ptr->get_debug_string (), ptr->get_type ()->get_debug_string ()); @@ -906,7 +917,7 @@ gcc_jit_context_new_array_access (gcc_jit_context *ctxt, gcc_jit_context * gcc_jit_object_get_context (gcc_jit_object *obj) { - RETURN_NULL_IF_FAIL (obj, NULL, "NULL object"); + RETURN_NULL_IF_FAIL (obj, NULL, NULL, "NULL object"); return static_cast (obj->get_context ()); } @@ -914,7 +925,7 @@ gcc_jit_object_get_context (gcc_jit_object *obj) const char * gcc_jit_object_get_debug_string (gcc_jit_object *obj) { - RETURN_NULL_IF_FAIL (obj, NULL, "NULL object"); + RETURN_NULL_IF_FAIL (obj, NULL, NULL, "NULL object"); return obj->get_debug_string (); } @@ -924,10 +935,10 @@ gcc_jit_lvalue_access_field (gcc_jit_lvalue *struct_, gcc_jit_location *loc, gcc_jit_field *field) { - RETURN_NULL_IF_FAIL (struct_, NULL, "NULL struct"); + RETURN_NULL_IF_FAIL (struct_, NULL, loc, "NULL struct"); gcc::jit::recording::context *ctxt = struct_->m_ctxt; - RETURN_NULL_IF_FAIL (field, ctxt, "NULL field"); - RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, + RETURN_NULL_IF_FAIL (field, ctxt, loc, "NULL field"); + RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, loc, "field %s has not been placed in a struct", field->get_debug_string ()); @@ -939,10 +950,10 @@ gcc_jit_rvalue_access_field (gcc_jit_rvalue *struct_, gcc_jit_location *loc, gcc_jit_field *field) { - RETURN_NULL_IF_FAIL (struct_, NULL, "NULL struct"); + RETURN_NULL_IF_FAIL (struct_, NULL, loc, "NULL struct"); gcc::jit::recording::context *ctxt = struct_->m_ctxt; - RETURN_NULL_IF_FAIL (field, ctxt, "NULL field"); - RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, + RETURN_NULL_IF_FAIL (field, ctxt, loc, "NULL field"); + RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, loc, "field %s has not been placed in a struct", field->get_debug_string ()); @@ -954,15 +965,16 @@ gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr, gcc_jit_location *loc, gcc_jit_field *field) { - RETURN_NULL_IF_FAIL (ptr, NULL, "NULL ptr"); - RETURN_NULL_IF_FAIL (field, NULL, "NULL field"); + RETURN_NULL_IF_FAIL (ptr, NULL, loc, "NULL ptr"); + RETURN_NULL_IF_FAIL (field, NULL, loc, "NULL field"); gcc::jit::recording::type *underlying_type = ptr->get_type ()->dereference (); - RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, + RETURN_NULL_IF_FAIL_PRINTF1 (field->get_container (), field->m_ctxt, loc, "field %s has not been placed in a struct", field->get_debug_string ()); RETURN_NULL_IF_FAIL_PRINTF3 ( - underlying_type, ptr->m_ctxt, + underlying_type, + ptr->m_ctxt, loc, "dereference of non-pointer %s (type: %s) when accessing ->%s", ptr->get_debug_string (), ptr->get_type ()->get_debug_string (), @@ -970,7 +982,7 @@ gcc_jit_rvalue_dereference_field (gcc_jit_rvalue *ptr, RETURN_NULL_IF_FAIL_PRINTF2 ( (field->get_container ()->unqualified () == underlying_type->unqualified ()), - ptr->m_ctxt, + ptr->m_ctxt, loc, "%s is not a field of %s", field->get_debug_string (), underlying_type->get_debug_string ()); @@ -982,13 +994,14 @@ gcc_jit_lvalue * gcc_jit_rvalue_dereference (gcc_jit_rvalue *rvalue, gcc_jit_location *loc) { - RETURN_NULL_IF_FAIL (rvalue, NULL, "NULL rvalue"); + RETURN_NULL_IF_FAIL (rvalue, NULL, loc, "NULL rvalue"); gcc::jit::recording::type *underlying_type = rvalue->get_type ()->dereference (); RETURN_NULL_IF_FAIL_PRINTF2 ( - underlying_type, rvalue->m_ctxt, + underlying_type, + rvalue->m_ctxt, loc, "dereference of non-pointer %s (type: %s)", rvalue->get_debug_string (), rvalue->get_type ()->get_debug_string ()); @@ -1000,7 +1013,7 @@ gcc_jit_rvalue * gcc_jit_lvalue_get_address (gcc_jit_lvalue *lvalue, gcc_jit_location *loc) { - RETURN_NULL_IF_FAIL (lvalue, NULL, "NULL lvalue"); + RETURN_NULL_IF_FAIL (lvalue, NULL, loc, "NULL lvalue"); return (gcc_jit_rvalue *)lvalue->get_address (loc); } @@ -1011,13 +1024,13 @@ gcc_jit_function_new_local (gcc_jit_function *func, gcc_jit_type *type, const char *name) { - RETURN_NULL_IF_FAIL (func, NULL, "NULL function"); + RETURN_NULL_IF_FAIL (func, NULL, loc, "NULL function"); gcc::jit::recording::context *ctxt = func->m_ctxt; RETURN_NULL_IF_FAIL (func->get_kind () != GCC_JIT_FUNCTION_IMPORTED, - ctxt, + ctxt, loc, "Cannot add locals to an imported function"); - RETURN_NULL_IF_FAIL (type, ctxt, "NULL type"); - RETURN_NULL_IF_FAIL (name, ctxt, "NULL name"); + RETURN_NULL_IF_FAIL (type, ctxt, loc, "NULL type"); + RETURN_NULL_IF_FAIL (name, ctxt, loc, "NULL name"); return (gcc_jit_lvalue *)func->new_local (loc, type, name); } @@ -1027,9 +1040,9 @@ gcc_jit_block_add_eval (gcc_jit_block *block, gcc_jit_location *loc, gcc_jit_rvalue *rvalue) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); - RETURN_IF_FAIL (rvalue, ctxt, "NULL rvalue"); + RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); return block->add_eval (loc, rvalue); } @@ -1040,14 +1053,14 @@ gcc_jit_block_add_assignment (gcc_jit_block *block, gcc_jit_lvalue *lvalue, gcc_jit_rvalue *rvalue) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); - RETURN_IF_FAIL (lvalue, ctxt, "NULL lvalue"); - RETURN_IF_FAIL (rvalue, ctxt, "NULL rvalue"); + RETURN_IF_FAIL (lvalue, ctxt, loc, "NULL lvalue"); + RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); RETURN_IF_FAIL_PRINTF4 ( compatible_types (lvalue->get_type (), rvalue->get_type ()), - ctxt, + ctxt, loc, "mismatching types:" " assignment to %s (type: %s) from %s (type: %s)", lvalue->get_debug_string (), @@ -1065,11 +1078,11 @@ gcc_jit_block_add_assignment_op (gcc_jit_block *block, enum gcc_jit_binary_op op, gcc_jit_rvalue *rvalue) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); - RETURN_IF_FAIL (lvalue, ctxt, "NULL lvalue"); + RETURN_IF_FAIL (lvalue, ctxt, loc, "NULL lvalue"); /* FIXME: op is checked by new_binary_op */ - RETURN_IF_FAIL (rvalue, ctxt, "NULL rvalue"); + RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); return block->add_assignment_op (loc, lvalue, op, rvalue); } @@ -1090,19 +1103,19 @@ gcc_jit_block_end_with_conditional (gcc_jit_block *block, gcc_jit_block *on_true, gcc_jit_block *on_false) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); - RETURN_IF_FAIL (boolval, ctxt, "NULL boolval"); + RETURN_IF_FAIL (boolval, ctxt, loc, "NULL boolval"); RETURN_IF_FAIL_PRINTF2 ( - is_bool (boolval), ctxt, + is_bool (boolval), ctxt, loc, "%s (type: %s) is not of boolean type ", boolval->get_debug_string (), boolval->get_type ()->get_debug_string ()); - RETURN_IF_FAIL (on_true, ctxt, "NULL on_true"); - RETURN_IF_FAIL (on_true, ctxt, "NULL on_false"); + RETURN_IF_FAIL (on_true, ctxt, loc, "NULL on_true"); + RETURN_IF_FAIL (on_true, ctxt, loc, "NULL on_false"); RETURN_IF_FAIL_PRINTF4 ( block->get_function () == on_true->get_function (), - ctxt, + ctxt, loc, "\"on_true\" block is not in same function:" " source block %s is in function %s" " whereas target block %s is in function %s", @@ -1112,7 +1125,7 @@ gcc_jit_block_end_with_conditional (gcc_jit_block *block, on_true->get_function ()->get_debug_string ()); RETURN_IF_FAIL_PRINTF4 ( block->get_function () == on_false->get_function (), - ctxt, + ctxt, loc, "\"on_false\" block is not in same function:" " source block %s is in function %s" " whereas target block %s is in function %s", @@ -1129,9 +1142,9 @@ gcc_jit_block_add_comment (gcc_jit_block *block, gcc_jit_location *loc, const char *text) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); - RETURN_IF_FAIL (text, ctxt, "NULL text"); + RETURN_IF_FAIL (text, ctxt, loc, "NULL text"); block->add_comment (loc, text); } @@ -1141,12 +1154,12 @@ gcc_jit_block_end_with_jump (gcc_jit_block *block, gcc_jit_location *loc, gcc_jit_block *target) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); - RETURN_IF_FAIL (target, ctxt, "NULL target"); + RETURN_IF_FAIL (target, ctxt, loc, "NULL target"); RETURN_IF_FAIL_PRINTF4 ( block->get_function () == target->get_function (), - ctxt, + ctxt, loc, "target block is not in same function:" " source block %s is in function %s" " whereas target block %s is in function %s", @@ -1163,15 +1176,15 @@ gcc_jit_block_end_with_return (gcc_jit_block *block, gcc_jit_location *loc, gcc_jit_rvalue *rvalue) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); gcc::jit::recording::function *func = block->get_function (); - RETURN_IF_FAIL (rvalue, ctxt, "NULL rvalue"); + RETURN_IF_FAIL (rvalue, ctxt, loc, "NULL rvalue"); RETURN_IF_FAIL_PRINTF4 ( compatible_types ( func->get_return_type (), rvalue->get_type ()), - ctxt, + ctxt, loc, "mismatching types:" " return of %s (type: %s) in function %s (return type: %s)", rvalue->get_debug_string (), @@ -1186,12 +1199,12 @@ void gcc_jit_block_end_with_void_return (gcc_jit_block *block, gcc_jit_location *loc) { - RETURN_IF_NOT_VALID_BLOCK (block); + RETURN_IF_NOT_VALID_BLOCK (block, loc); gcc::jit::recording::context *ctxt = block->get_context (); gcc::jit::recording::function *func = block->get_function (); RETURN_IF_FAIL_PRINTF2 ( func->get_return_type () == ctxt->get_type (GCC_JIT_TYPE_VOID), - ctxt, + ctxt, loc, "mismatching types:" " void return in function %s (return type: %s)", func->get_debug_string (), @@ -1209,7 +1222,7 @@ gcc_jit_context_set_str_option (gcc_jit_context *ctxt, enum gcc_jit_str_option opt, const char *value) { - RETURN_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context"); /* opt is checked by the inner function. value can be NULL. */ @@ -1221,7 +1234,7 @@ gcc_jit_context_set_int_option (gcc_jit_context *ctxt, enum gcc_jit_int_option opt, int value) { - RETURN_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context"); /* opt is checked by the inner function. */ ctxt->set_int_option (opt, value); @@ -1232,7 +1245,7 @@ gcc_jit_context_set_bool_option (gcc_jit_context *ctxt, enum gcc_jit_bool_option opt, int value) { - RETURN_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context"); /* opt is checked by the inner function. */ ctxt->set_bool_option (opt, value); @@ -1241,7 +1254,7 @@ gcc_jit_context_set_bool_option (gcc_jit_context *ctxt, gcc_jit_result * gcc_jit_context_compile (gcc_jit_context *ctxt) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); return (gcc_jit_result *)ctxt->compile (); } @@ -1251,15 +1264,15 @@ gcc_jit_context_dump_to_file (gcc_jit_context *ctxt, const char *path, int update_locations) { - RETURN_IF_FAIL (ctxt, NULL, "NULL context"); - RETURN_IF_FAIL (path, ctxt, "NULL path"); + RETURN_IF_FAIL (ctxt, NULL, NULL, "NULL context"); + RETURN_IF_FAIL (path, ctxt, NULL, "NULL path"); ctxt->dump_to_file (path, update_locations); } const char * gcc_jit_context_get_first_error (gcc_jit_context *ctxt) { - RETURN_NULL_IF_FAIL (ctxt, NULL, "NULL context"); + RETURN_NULL_IF_FAIL (ctxt, NULL, NULL, "NULL context"); return ctxt->get_first_error (); } @@ -1268,8 +1281,8 @@ void * gcc_jit_result_get_code (gcc_jit_result *result, const char *fnname) { - RETURN_NULL_IF_FAIL (result, NULL, "NULL result"); - RETURN_NULL_IF_FAIL (fnname, NULL, "NULL fnname"); + RETURN_NULL_IF_FAIL (result, NULL, NULL, "NULL result"); + RETURN_NULL_IF_FAIL (fnname, NULL, NULL, "NULL fnname"); return result->get_code (fnname); } @@ -1277,7 +1290,7 @@ gcc_jit_result_get_code (gcc_jit_result *result, void gcc_jit_result_release (gcc_jit_result *result) { - RETURN_IF_FAIL (result, NULL, "NULL result"); + RETURN_IF_FAIL (result, NULL, NULL, "NULL result"); delete result; }