From 8154a3514d5fc8067a6928531d5f61cd768bd62c Mon Sep 17 00:00:00 2001 From: dmalcolm Date: Tue, 16 Jun 2015 18:13:44 +0000 Subject: PR jit/66539: Add parentheses as needed to gcc_jit_object_get_debug_string gcc/jit/ChangeLog: PR jit/66539 * jit-recording.c: Within namespace gcc::jit::recording:: (rvalue::get_debug_string_parens): New function. (binary_op::make_debug_string): Update to mimic C precedence rules. (binary_op_precedence): New array. (binary_op::get_precedence): New function. (comparison::make_debug_string): Update to mimic C precedence rules. (comparison_precedence): New array. (comparison::get_precedence): New function. (cast::make_debug_string): Update to mimic C precedence rules. (call::make_debug_string): Likewise. (call_through_ptr::make_debug_string): Likewise. (array_access::make_debug_string): Likewise. (access_field_of_lvalue::make_debug_string): Likewise. (access_field_rvalue::make_debug_string): Likewise. (dereference_field_rvalue::make_debug_string): Likewise. (dereference_rvalue::make_debug_string): Likewise. (get_address_of_lvalue::make_debug_string): Likewise. * jit-recording.h: Within namespace gcc::jit::recording:: (precedence): New enum. (rvalue::rvalue): Initialize field "m_parenthesized_string". (rvalue::get_debug_string_parens): New method. (rvalue::get_precedence): New pure virtual function. (rvalue::m_parenthesized_string): New field. (param::get_precedence): New function. (global::get_precedence): New function. (memento_of_new_rvalue_from_const::get_precedence): New function. (memento_of_new_string_literal::get_precedence): New function. (unary_op::get_precedence): New function. (binary_op::get_precedence): New function. (comparison::get_precedence): New function. (cast::get_precedence): New function. (call::get_precedence): New function. (call_through_ptr::get_precedence): New function. (array_access::get_precedence): New function. (access_field_of_lvalue::get_precedence): New function. (access_field_rvalue::get_precedence): New function. (dereference_field_rvalue::get_precedence): New function. (dereference_rvalue::get_precedence): New function. (get_address_of_lvalue::get_precedence): New function. (local::get_precedence): New function. gcc/testsuite/ChangeLog: PR jit/66539 * jit.dg/all-non-failing-tests.h: Add test-debug-strings.c. * jit.dg/test-debug-strings.c: New test case. * jit.dg/test-quadratic.c (make_calc_discriminant): Verify that the discriminant has a sane debug string. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@224531 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/testsuite/jit.dg/test-debug-strings.c | 190 ++++++++++++++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 gcc/testsuite/jit.dg/test-debug-strings.c (limited to 'gcc/testsuite/jit.dg/test-debug-strings.c') diff --git a/gcc/testsuite/jit.dg/test-debug-strings.c b/gcc/testsuite/jit.dg/test-debug-strings.c new file mode 100644 index 00000000000..e515a176257 --- /dev/null +++ b/gcc/testsuite/jit.dg/test-debug-strings.c @@ -0,0 +1,190 @@ +#include +#include + +#include "libgccjit.h" + +#include "harness.h" + +/* Build various compound expressions, and verify that they have sane debug + strings. */ +void +create_code (gcc_jit_context *ctxt, void *user_data) +{ + /* Make a singly-linked list type: + struct node + { + struct node *next; + int value; + }; + */ + gcc_jit_type *t_int = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); + gcc_jit_struct *t_node = + gcc_jit_context_new_opaque_struct (ctxt, NULL, "node"); + gcc_jit_type *t_node_ptr = + gcc_jit_type_get_pointer (gcc_jit_struct_as_type (t_node)); + gcc_jit_field *f_next = + gcc_jit_context_new_field (ctxt, NULL, t_node_ptr, "next"); + gcc_jit_field *f_value = + gcc_jit_context_new_field (ctxt, NULL, t_int, "value"); + gcc_jit_field *fields[] = {f_next, f_value}; + gcc_jit_struct_set_fields (t_node, NULL, 2, fields); + + /* Create a dummy function so that we have locals/params to build + expressions with. */ + gcc_jit_type *t_void = + gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID); + gcc_jit_function *fn = + gcc_jit_context_new_function (ctxt, NULL, + GCC_JIT_FUNCTION_EXPORTED, + t_void, + "test_debug_strings", + 0, NULL, 0); + gcc_jit_rvalue *ptr = + gcc_jit_lvalue_as_rvalue ( + gcc_jit_function_new_local (fn, + NULL, + t_node_ptr, + "ptr")); + gcc_jit_rvalue *a = + gcc_jit_lvalue_as_rvalue ( + gcc_jit_function_new_local (fn, NULL, t_int, "a")); + gcc_jit_rvalue *b = + gcc_jit_lvalue_as_rvalue ( + gcc_jit_function_new_local (fn, NULL, t_int, "b")); + gcc_jit_rvalue *c = + gcc_jit_lvalue_as_rvalue ( + gcc_jit_function_new_local (fn, NULL, t_int, "c")); + gcc_jit_rvalue *d = + gcc_jit_lvalue_as_rvalue ( + gcc_jit_function_new_local (fn, NULL, t_int, "d")); + +#define CHECK_RVALUE_DEBUG_STRING(RVALUE, EXPECTED) \ + CHECK_STRING_VALUE ( \ + gcc_jit_object_get_debug_string (gcc_jit_rvalue_as_object (RVALUE)), \ + (EXPECTED)) + +#define CHECK_LVALUE_DEBUG_STRING(LVALUE, EXPECTED) \ + CHECK_STRING_VALUE ( \ + gcc_jit_object_get_debug_string (gcc_jit_lvalue_as_object (LVALUE)), \ + (EXPECTED)) + + /* Verify various simple compound expressions. */ + { + CHECK_RVALUE_DEBUG_STRING (ptr, "ptr"); + + gcc_jit_lvalue *deref = + gcc_jit_rvalue_dereference_field (ptr, + NULL, + f_value); + CHECK_LVALUE_DEBUG_STRING (deref, "ptr->value"); + + gcc_jit_rvalue *deref_as_rvalue = gcc_jit_lvalue_as_rvalue (deref); + +#define BINOP(OP, A, B) \ + gcc_jit_context_new_binary_op (ctxt, NULL, \ + GCC_JIT_BINARY_OP_##OP, t_int, (A), (B)) +#define COMPARISON(OP, A, B) \ + gcc_jit_context_new_comparison (ctxt, NULL, \ + GCC_JIT_COMPARISON_##OP,(A), (B)) + + CHECK_RVALUE_DEBUG_STRING ( + BINOP (PLUS, deref_as_rvalue, deref_as_rvalue), + "ptr->value + ptr->value"); + CHECK_RVALUE_DEBUG_STRING ( + BINOP (MULT, deref_as_rvalue, deref_as_rvalue), + "ptr->value * ptr->value"); + + /* Multiplication has higher precedence in C than addition, so this + dump shouldn't contain parentheses. */ + CHECK_RVALUE_DEBUG_STRING ( + BINOP (PLUS, + BINOP (MULT, a, b), + BINOP (MULT, c, d)), + "a * b + c * d"); + + /* ...but this one should. */ + CHECK_RVALUE_DEBUG_STRING ( + BINOP (MULT, + BINOP (PLUS, a, b), + BINOP (PLUS, c, d)), + "(a + b) * (c + d)"); + + /* Equal precedences don't need parentheses. */ + CHECK_RVALUE_DEBUG_STRING ( + BINOP (MULT, + BINOP (MULT, a, b), + BINOP (MULT, c, d)), + "a * b * c * d"); + + /* Comparisons and logical ops. */ + CHECK_RVALUE_DEBUG_STRING ( + COMPARISON (LT, a, b), + "a < b"); + + CHECK_RVALUE_DEBUG_STRING ( + BINOP (LOGICAL_AND, + COMPARISON (LT, a, b), + COMPARISON (GT, c, d)), + "a < b && c > d"); + + CHECK_RVALUE_DEBUG_STRING ( + BINOP (LOGICAL_AND, + BINOP (LOGICAL_OR, + COMPARISON (LT, a, b), + COMPARISON (LT, a, c)), + BINOP (LOGICAL_OR, + COMPARISON (GT, d, b), + COMPARISON (GT, d, c))), + "(a < b || a < c) && (d > b || d > c)"); + + CHECK_RVALUE_DEBUG_STRING ( + BINOP (LOGICAL_OR, + BINOP (LOGICAL_AND, + COMPARISON (LT, a, b), + COMPARISON (LT, a, c)), + BINOP (LOGICAL_AND, + COMPARISON (GT, d, b), + COMPARISON (GT, d, c))), + "a < b && a < c || d > b && d > c"); + +#undef BINOP +#undef COMPARISON + } + + /* PR jit/66539 "Missing parentheses in jit dumps". + Construct the equivalent of + ((cast)ptr->next)->next + and verify that the appropriate parentheses appear in the debug + string. */ + { + /* "ptr->next". */ + gcc_jit_lvalue *inner_deref = + gcc_jit_rvalue_dereference_field (ptr, + NULL, + f_next); + /* "((node *)ptr->next)"; the cast is redundant, purely + to exercise dumping. */ + gcc_jit_rvalue *test_cast = + gcc_jit_context_new_cast (ctxt, NULL, + gcc_jit_lvalue_as_rvalue (inner_deref), + t_node_ptr); + /* "((node *)ptr->next)->next". */ + gcc_jit_lvalue *outer_deref = + gcc_jit_rvalue_dereference_field (test_cast, /* gcc_jit_rvalue *ptr */ + NULL, /* gcc_jit_location *loc */ + f_next); /* gcc_jit_field *field */ + CHECK_LVALUE_DEBUG_STRING (outer_deref, + "((struct node *)ptr->next)->next"); + } + +#undef CHECK_LVALUE_DEBUG_STRING +} + +void +verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) +{ + CHECK_NON_NULL (result); + /* We don't actually build any functions above; + nothing more to verify. */ +} -- cgit v1.2.3