Issue 6188088: Turn check macros into functions.

Lawrence Crowl

The gcc source uses several constructs that GDB does not understand. This patch corrects some ...

11 years, 11 months ago (2012-05-15 17:19:17 UTC) #1

The gcc source uses several constructs that GDB does not understand.
This patch corrects some of them.  It affects only compilers built
with ENABLE_TREE_CHECKING, and hence release compilers are unaffected.

In particular, I change the implementation of CHECK macros using
__extension__ into macros calling template inline functions.  I do not
change the accessor macros themselves.

The effect is that it now possible to get useful responses to gdb
command like

    (gdb) print DECL_FUNCTION_CODE (decl)

To make the feature work, you must define two macros within gdb.

    (gdb) macro define __FILE__ "gdb"
    (gdb) macro define __LINE__ 1

The reason for these definitions is that gdb does not expand the magic
preprocessor macros, and then cannot find what it thinks is a regular
symbol.  (There is now a gdb issue for this problem.)  I added these
definitions to gdbinit.in.

The inline functions would normally introduce additional lines in a
sequence of gdb 'step' commands.  To prevent that behavior, I have
added the new 'skip' command for the "tree.h" file to gdbinit.in.  The
'skip' command works with gdb 7.4 and later.

(The better solution to the stepping behavior is a new gdb command.
See http://sourceware.org/bugzilla/show_bug.cgi?id=12940.)

Tested on x86-64.

Index: gcc/ChangeLog.cxx-conversion

2012-05-15  Lawrence Crowl  <crowl@google.com>

	* tree.h (tree_check): New.
	(TREE_CHECK): Use inline function above instead of __extension__.
	(tree_not_check): New.
	(TREE_NOT_CHECK): Use inline function above instead of __extension__.
	(tree_check2): New.
	(TREE_CHECK2): Use inline function above instead of __extension__.
	(tree_not_check2): New.
	(TREE_NOT_CHECK2): Use inline function above instead of __extension__.
	(tree_check3): New.
	(TREE_CHECK3): Use inline function above instead of __extension__.
	(tree_not_check3): New.
	(TREE_NOT_CHECK3): Use inline function above instead of __extension__.
	(tree_check4): New.
	(TREE_CHECK4): Use inline function above instead of __extension__.
	(tree_not_check4): New.
	(TREE_NOT_CHECK4): Use inline function above instead of __extension__.
	(tree_check5): New.
	(TREE_CHECK5): Use inline function above instead of __extension__.
	(tree_not_check5): New.
	(TREE_NOT_CHECK5): Use inline function above instead of __extension__.
	(contains_struct_check): New.
	(CONTAINS_STRUCT_CHECK): Use inline function above instead of
	__extension__.
	(tree_class_check): New.
	(TREE_CLASS_CHECK): Use inline function above instead of __extension__.
	(tree_range_check): New.
	(TREE_RANGE_CHECK): Use inline function above instead of __extension__.
	(omp_clause_subcode_check): New.
	(OMP_CLAUSE_SUBCODE_CHECK): Use inline function above instead of
	__extension__.
	(omp_clause_range_check): New.
	(OMP_CLAUSE_RANGE_CHECK): Use inline function above instead of
	__extension__.
	(expr_check): New.
	(EXPR_CHECK): Use inline function above instead of __extension__.
	(non_type_check): New.
	(NON_TYPE_CHECK): Use inline function above instead of __extension__.
	(tree_vec_elt_check): New.
	(TREE_VEC_ELT_CHECK): Use inline function above instead of
	__extension__.
	(omp_clause_elt_check): New.
	(OMP_CLAUSE_ELT_CHECK): Use inline function above instead of
	__extension__.
	(tree_operand_check): New.
	(TREE_OPERAND_CHECK): Use inline function above instead of
	__extension__.
	(tree_operand_check_code): New.
	(TREE_OPERAND_CHECK_CODE): Use inline function above instead of
	__extension__.
	(TREE_CHAIN): Simplify implementation.
	(TREE_TYPE): Simplify implementation.
	(tree_operand_length): Move for compilation dependences.
	* gdbinit.in: (macro define __FILE__): New.
	(macro define __LINE__): New.
	(skip "tree.h"): New.


Index: gcc/tree.h
===================================================================
--- gcc/tree.h	(revision 187477)
+++ gcc/tree.h	(working copy)
@@ -727,195 +727,80 @@ enum tree_node_structure_enum {
    is accessed incorrectly. The macros die with a fatal error.  */
 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
 
-#define TREE_CHECK(T, CODE) __extension__				\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != (CODE))					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 	\
-			 (CODE), 0);					\
-    __t; })
+#define TREE_CHECK(T, CODE) \
+(tree_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
 
-#define TREE_NOT_CHECK(T, CODE) __extension__				\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) == (CODE))					\
-      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,	\
-			     (CODE), 0);				\
-    __t; })
+#define TREE_NOT_CHECK(T, CODE) \
+(tree_not_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
 
-#define TREE_CHECK2(T, CODE1, CODE2) __extension__			\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != (CODE1)					\
-	&& TREE_CODE (__t) != (CODE2))					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,		\
- 			 (CODE1), (CODE2), 0);				\
-    __t; })
+#define TREE_CHECK2(T, CODE1, CODE2) \
+(tree_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
 
-#define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__			\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) == (CODE1)					\
-	|| TREE_CODE (__t) == (CODE2))					\
-      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,	\
-			     (CODE1), (CODE2), 0);			\
-    __t; })
+#define TREE_NOT_CHECK2(T, CODE1, CODE2) \
+(tree_not_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
 
-#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__		\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != (CODE1)					\
-	&& TREE_CODE (__t) != (CODE2)					\
-	&& TREE_CODE (__t) != (CODE3))					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,		\
-			     (CODE1), (CODE2), (CODE3), 0);		\
-    __t; })
+#define TREE_CHECK3(T, CODE1, CODE2, CODE3) \
+(tree_check3 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2),
(CODE3)))
 
-#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__		\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) == (CODE1)					\
-	|| TREE_CODE (__t) == (CODE2)					\
-	|| TREE_CODE (__t) == (CODE3))					\
-      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,	\
-			     (CODE1), (CODE2), (CODE3), 0);		\
-    __t; })
+#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) \
+(tree_not_check3 ((T), __FILE__, __LINE__, __FUNCTION__, \
+                               (CODE1), (CODE2), (CODE3)))
 
-#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__	\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != (CODE1)					\
-	&& TREE_CODE (__t) != (CODE2)					\
-	&& TREE_CODE (__t) != (CODE3)					\
-	&& TREE_CODE (__t) != (CODE4))					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,		\
-			     (CODE1), (CODE2), (CODE3), (CODE4), 0);	\
-    __t; })
+#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
+(tree_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
+                           (CODE1), (CODE2), (CODE3), (CODE4)))
 
-#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__	\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) == (CODE1)					\
-	|| TREE_CODE (__t) == (CODE2)					\
-	|| TREE_CODE (__t) == (CODE3)					\
-	|| TREE_CODE (__t) == (CODE4))					\
-      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,	\
-			     (CODE1), (CODE2), (CODE3), (CODE4), 0);	\
-    __t; })
+#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
+(tree_not_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
+                               (CODE1), (CODE2), (CODE3), (CODE4)))
 
-#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__	\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != (CODE1)					\
-	&& TREE_CODE (__t) != (CODE2)					\
-	&& TREE_CODE (__t) != (CODE3)					\
-	&& TREE_CODE (__t) != (CODE4)					\
-	&& TREE_CODE (__t) != (CODE5))					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,		\
-			     (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
-    __t; })
+#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
+(tree_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
+                           (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
 
-#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) == (CODE1)					\
-	|| TREE_CODE (__t) == (CODE2)					\
-	|| TREE_CODE (__t) == (CODE3)					\
-	|| TREE_CODE (__t) == (CODE4)					\
-	|| TREE_CODE (__t) == (CODE5))					\
-      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,	\
-			     (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
-    __t; })
+#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
+(tree_not_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
+                               (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
 
-#define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__			\
-({  __typeof (T) const __t = (T);					\
-  if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1)		\
-      tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__,	\
-			       __FUNCTION__);				\
-    __t; })
+#define CONTAINS_STRUCT_CHECK(T, STRUCT) \
+(contains_struct_check ((T), (STRUCT), __FILE__, __LINE__, __FUNCTION__))
 
-#define TREE_CLASS_CHECK(T, CLASS) __extension__			\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS))			\
-      tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__,	\
-			       __FUNCTION__);				\
-    __t; })
+#define TREE_CLASS_CHECK(T, CLASS) \
+(tree_class_check ((T), (CLASS), __FILE__, __LINE__, __FUNCTION__))
 
-#define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__			\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) < (CODE1) || TREE_CODE (__t) > (CODE2))		\
-      tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,	\
-			       (CODE1), (CODE2));			\
-    __t; })
+#define TREE_RANGE_CHECK(T, CODE1, CODE2) \
+(tree_range_check ((T), (CODE1), (CODE2), __FILE__, __LINE__, __FUNCTION__))
 
-#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__			\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != OMP_CLAUSE)					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,  	\
-			 OMP_CLAUSE, 0);				\
-    if (__t->omp_clause.code != (CODE))					\
-      omp_clause_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, 	\
-			       (CODE));					\
-    __t; })
+#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) \
+(omp_clause_subcode_check ((T), (CODE), __FILE__, __LINE__, __FUNCTION__))
 
-#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__		\
-({  __typeof (T) const __t = (T);					\
-    if (TREE_CODE (__t) != OMP_CLAUSE)					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,  	\
-			 OMP_CLAUSE, 0);				\
-    if ((int) __t->omp_clause.code < (int) (CODE1)			\
-        || (int) __t->omp_clause.code > (int) (CODE2))			\
-      omp_clause_range_check_failed (__t, __FILE__, __LINE__,		\
-				     __FUNCTION__, (CODE1), (CODE2));	\
-    __t; })
+#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) \
+(omp_clause_range_check ((T), (CODE1), (CODE2), \
+                                      __FILE__, __LINE__, __FUNCTION__))
 
 /* These checks have to be special cased.  */
-#define EXPR_CHECK(T) __extension__					\
-({  __typeof (T) const __t = (T);					\
-    char const __c = TREE_CODE_CLASS (TREE_CODE (__t));			\
-    if (!IS_EXPR_CODE_CLASS (__c))					\
-      tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__,	\
-			       __FUNCTION__);				\
-    __t; })
+#define EXPR_CHECK(T) \
+(expr_check ((T), __FILE__, __LINE__, __FUNCTION__))
 
 /* These checks have to be special cased.  */
-#define NON_TYPE_CHECK(T) __extension__					\
-({  __typeof (T) const __t = (T);					\
-    if (TYPE_P (__t))							\
-      tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__,	\
-				   __FUNCTION__);			\
-    __t; })
+#define NON_TYPE_CHECK(T) \
+(non_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
 
-#define TREE_VEC_ELT_CHECK(T, I) __extension__				\
-(*({__typeof (T) const __t = (T);					\
-    const int __i = (I);						\
-    if (TREE_CODE (__t) != TREE_VEC)					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,		\
-  			 TREE_VEC, 0);					\
-    if (__i < 0 || __i >= __t->vec.length)				\
-      tree_vec_elt_check_failed (__i, __t->vec.length,			\
-				 __FILE__, __LINE__, __FUNCTION__);	\
-    &__t->vec.a[__i]; }))
+#define TREE_VEC_ELT_CHECK(T, I) \
+(*(CONST_CAST2 (tree *, typeof (T)*, \
+     tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
 
-#define OMP_CLAUSE_ELT_CHECK(T, I) __extension__			\
-(*({__typeof (T) const __t = (T);					\
-    const int __i = (I);						\
-    if (TREE_CODE (__t) != OMP_CLAUSE)					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,  	\
-			 OMP_CLAUSE, 0);				\
-    if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])	\
-      omp_clause_operand_check_failed (__i, __t, __FILE__, __LINE__,	\
-	                               __FUNCTION__);			\
-    &__t->omp_clause.ops[__i]; }))
+#define OMP_CLAUSE_ELT_CHECK(T, I) \
+(*(omp_clause_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))
 
 /* Special checks for TREE_OPERANDs.  */
-#define TREE_OPERAND_CHECK(T, I) __extension__				\
-(*({__typeof (T) const __t = EXPR_CHECK (T);				\
-    const int __i = (I);						\
-    if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))			\
-      tree_operand_check_failed (__i, __t,				\
-				 __FILE__, __LINE__, __FUNCTION__);	\
-    &__t->exp.operands[__i]; }))
+#define TREE_OPERAND_CHECK(T, I) \
+(*(CONST_CAST2 (tree*, typeof (T)*, \
+     tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
 
-#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__		\
-(*({__typeof (T) const __t = (T);					\
-    const int __i = (I);						\
-    if (TREE_CODE (__t) != CODE)					\
-      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\
-    if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))			\
-      tree_operand_check_failed (__i, __t,				\
-				 __FILE__, __LINE__, __FUNCTION__);	\
-    &__t->exp.operands[__i]; }))
+#define TREE_OPERAND_CHECK_CODE(T, CODE, I) \
+(*(tree_operand_check_code ((T), (CODE), (I), \
+                                         __FILE__, __LINE__, __FUNCTION__)))
 
 /* Nodes are chained together for many purposes.
    Types are chained together to record them for being output to the debugger
@@ -926,17 +811,15 @@ enum tree_node_structure_enum {
    Often lists of things are represented by TREE_LIST nodes that
    are chained together.  */
 
-#define TREE_CHAIN(NODE) __extension__ \
-(*({__typeof (NODE) const __t = CONTAINS_STRUCT_CHECK (NODE, TS_COMMON);\
-    &__t->common.chain; }))
+#define TREE_CHAIN(NODE) \
+(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)->common.chain)
 
 /* In all nodes that are expressions, this is the data type of the expression.
    In POINTER_TYPE nodes, this is the type that the pointer points to.
    In ARRAY_TYPE nodes, this is the type of the elements.
    In VECTOR_TYPE nodes, this is the type of the elements.  */
-#define TREE_TYPE(NODE) __extension__ \
-(*({__typeof (NODE) const __t = CONTAINS_STRUCT_CHECK (NODE, TS_TYPED); \
-    &__t->typed.type; }))
+#define TREE_TYPE(NODE) \
+(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)->typed.type)
 
 extern void tree_contains_struct_check_failed (const_tree,
 					       const enum tree_node_structure_enum,
@@ -3718,6 +3601,273 @@ union GTY ((ptr_alias (union lang_tree_n
   struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION")))
optimization;
   struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
 };
+
+
+#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
+
+template <typename Tree>
+inline Tree
+tree_check (Tree __t, const char *__f, int __l, const char *__g, tree_code
__c)
+{
+  if (TREE_CODE (__t) != __c)
+    tree_check_failed (__t, __f, __l, __g, __c, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_not_check (Tree __t, const char *__f, int __l, const char *__g,
+                enum tree_code __c)
+{
+  if (TREE_CODE (__t) == __c)
+    tree_not_check_failed (__t, __f, __l, __g, __c, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_check2 (Tree __t, const char *__f, int __l, const char *__g,
+             enum tree_code __c1, enum tree_code __c2)
+{
+  if (TREE_CODE (__t) != __c1
+      && TREE_CODE (__t) != __c2)
+    tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_not_check2 (Tree __t, const char *__f, int __l, const char *__g,
+                 enum tree_code __c1, enum tree_code __c2)
+{
+  if (TREE_CODE (__t) == __c1
+      || TREE_CODE (__t) == __c2)
+    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_check3 (Tree __t, const char *__f, int __l, const char *__g,
+             enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
+{
+  if (TREE_CODE (__t) != __c1
+      && TREE_CODE (__t) != __c2
+      && TREE_CODE (__t) != __c3)
+    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_not_check3 (Tree __t, const char *__f, int __l, const char *__g,
+                 enum tree_code __c1, enum tree_code __c2, enum tree_code
__c3)
+{
+  if (TREE_CODE (__t) == __c1
+      || TREE_CODE (__t) == __c2
+      || TREE_CODE (__t) == __c3)
+    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_check4 (Tree __t, const char *__f, int __l, const char *__g,
+             enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
+             enum tree_code __c4)
+{
+  if (TREE_CODE (__t) != __c1
+      && TREE_CODE (__t) != __c2
+      && TREE_CODE (__t) != __c3
+      && TREE_CODE (__t) != __c4)
+    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_not_check4 (Tree __t, const char *__f, int __l, const char *__g,
+                 enum tree_code __c1, enum tree_code __c2, enum tree_code
__c3,
+                 enum tree_code __c4)
+{
+  if (TREE_CODE (__t) == __c1
+      || TREE_CODE (__t) == __c2
+      || TREE_CODE (__t) == __c3
+      || TREE_CODE (__t) == __c4)
+    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_check5 (Tree __t, const char *__f, int __l, const char *__g,
+             enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
+             enum tree_code __c4, enum tree_code __c5)
+{
+  if (TREE_CODE (__t) != __c1
+      && TREE_CODE (__t) != __c2
+      && TREE_CODE (__t) != __c3
+      && TREE_CODE (__t) != __c4
+      && TREE_CODE (__t) != __c5)
+    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_not_check5 (Tree __t, const char *__f, int __l, const char *__g,
+                 enum tree_code __c1, enum tree_code __c2, enum tree_code
__c3,
+                 enum tree_code __c4, enum tree_code __c5)
+{
+  if (TREE_CODE (__t) == __c1
+      || TREE_CODE (__t) == __c2
+      || TREE_CODE (__t) == __c3
+      || TREE_CODE (__t) == __c4
+      || TREE_CODE (__t) == __c5)
+    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
0);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+contains_struct_check (Tree __t, const enum tree_node_structure_enum __s,
+                       const char *__f, int __l, const char *__g)
+{
+  if (tree_contains_struct[TREE_CODE(__t)][__s] != 1)
+      tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_class_check (Tree __t, const enum tree_code_class __class,
+                  const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE_CLASS (TREE_CODE(__t)) != __class)
+    tree_class_check_failed (__t, __class, __f, __l, __g);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+tree_range_check (Tree __t,
+                  enum tree_code __code1, enum tree_code __code2,
+                  const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
+    tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+omp_clause_subcode_check (Tree __t, enum omp_clause_code __code,
+                          const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE (__t) != OMP_CLAUSE)
+    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
+  if (__t->omp_clause.code != __code)
+    omp_clause_check_failed (__t, __f, __l, __g, __code);
+  return __t;
+}
+
+template <typename Tree>
+inline Tree
+omp_clause_range_check (Tree __t,
+                        enum omp_clause_code __code1,
+                        enum omp_clause_code __code2,
+                        const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE (__t) != OMP_CLAUSE)
+    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
+  if ((int) __t->omp_clause.code < (int) __code1
+      || (int) __t->omp_clause.code > (int) __code2)
+    omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
+  return __t;
+}
+
+/* These checks have to be special cased.  */
+template <typename Tree>
+inline Tree
+expr_check (Tree __t, const char *__f, int __l, const char *__g)
+{
+  char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
+  if (!IS_EXPR_CODE_CLASS (__c))
+    tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
+  return __t;
+}
+
+/* These checks have to be special cased.  */
+template <typename Tree>
+inline Tree
+non_type_check (Tree __t, const char *__f, int __l, const char *__g)
+{
+  if (TYPE_P (__t))
+    tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
+  return __t;
+}
+
+template <typename Tree>
+inline tree *
+tree_vec_elt_check (Tree __t, int __i,
+                    const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE (__t) != TREE_VEC)
+    tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
+  if (__i < 0 || __i >= __t->vec.length)
+    tree_vec_elt_check_failed (__i, __t->vec.length, __f, __l, __g);
+  return &CONST_CAST_TREE (__t)->vec.a[__i];
+}
+
+template <typename Tree>
+inline Tree *
+omp_clause_elt_check (Tree __t, int __i,
+                      const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE (__t) != OMP_CLAUSE)
+    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
+  if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
+    omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
+  return &__t->omp_clause.ops[__i];
+}
+
+/* Compute the number of operands in an expression node NODE.  For
+   tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
+   otherwise it is looked up from the node's code.  */
+static inline int
+tree_operand_length (const_tree node)
+{
+  if (VL_EXP_CLASS_P (node))
+    return VL_EXP_OPERAND_LENGTH (node);
+  else
+    return TREE_CODE_LENGTH (TREE_CODE (node));
+}
+
+/* Special checks for TREE_OPERANDs.  */
+template <typename Tree>
+inline tree *
+tree_operand_check (Tree __t, int __i,
+                    const char *__f, int __l, const char *__g)
+{
+  const_tree __u = EXPR_CHECK (__t);
+  if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
+    tree_operand_check_failed (__i, __u, __f, __l, __g);
+  return &CONST_CAST_TREE (__u)->exp.operands[__i];
+}
+
+template <typename Tree>
+inline Tree *
+tree_operand_check_code (Tree __t, enum tree_code __code, int __i,
+                         const char *__f, int __l, const char *__g)
+{
+  if (TREE_CODE (__t) != __code)
+    tree_check_failed (__t, __f, __l, __g, __code, 0);
+  if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
+    tree_operand_check_failed (__i, __t, __f, __l, __g);
+  return &__t->exp.operands[__i];
+}
+
+#endif
 
 /* Standard named or nameless data types of the C compiler.  */
 
@@ -5895,18 +6045,6 @@ is_tm_safe_or_pure (const_tree x)
 
 void init_inline_once (void);
 
-/* Compute the number of operands in an expression node NODE.  For
-   tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
-   otherwise it is looked up from the node's code.  */
-static inline int
-tree_operand_length (const_tree node)
-{
-  if (VL_EXP_CLASS_P (node))
-    return VL_EXP_OPERAND_LENGTH (node);
-  else
-    return TREE_CODE_LENGTH (TREE_CODE (node));
-}
-
 /* Abstract iterators for CALL_EXPRs.  These static inline definitions
    have to go towards the end of tree.h so that union tree_node is fully
    defined by this point.  */
Index: gcc/gdbinit.in
===================================================================
--- gcc/gdbinit.in	(revision 187477)
+++ gcc/gdbinit.in	(working copy)
@@ -182,6 +182,14 @@ document pbm
 Dump the bitmap that is in $ as a comma-separated list of numbers.
 end
 
+# Define some macros helpful to gdb when it is expanding macros.
+macro define __FILE__ "gdb"
+macro define __LINE__ 1
+
+# Skip all inline functions in tree.h.
+# These are used in accessor macros.
+skip "tree.h"
+
 # Put breakpoints at exit and fancy_abort in case abort is mapped
 # to either fprintf/exit or fancy_abort.
 b fancy_abort

--
This patch is available for review at http://codereview.appspot.com/6188088

Sign in to reply to this message.

stevenb.gcc

On Tue, May 15, 2012 at 7:19 PM, Lawrence Crowl <crowl@google.com> wrote: > The gcc ...

11 years, 11 months ago (2012-05-15 18:23:19 UTC) #2

Diego Novillo

On 12-05-15 14:23 , Steven Bosscher wrote: > On Tue, May 15, 2012 at 7:19 ...

11 years, 11 months ago (2012-05-15 19:15:02 UTC) #3

mikestump_comcast.net

On May 15, 2012, at 11:23 AM, Steven Bosscher wrote: > On Tue, May 15, ...

11 years, 11 months ago (2012-05-15 21:06:23 UTC) #4

On May 15, 2012, at 11:23 AM, Steven Bosscher wrote:
> On Tue, May 15, 2012 at 7:19 PM, Lawrence Crowl <crowl@google.com> wrote:
>> The gcc source uses several constructs that GDB does not understand.
>> This patch corrects some of them.  It affects only compilers built
>> with ENABLE_TREE_CHECKING, and hence release compilers are unaffected.
>> Index: gcc/ChangeLog.cxx-conversion
> (...)
>> 
>> 2012-05-15  Lawrence Crowl  <crowl@google.com>
>> 
> 
> Is this something you could do for the mainline instead?
> 
> If not, then I hope it will land there some day. I now usually build
> my debug compilers with checking disabled to work around this issue..

Gosh, we compile with -g3, and use:

macro define TREE_CHECK(T, CODE) (T) 
macro define TREE_NOT_CHECK(T, CODE) (T) 
macro define TREE_CHECK2(T, CODE1, CODE2) (T) 
macro define TREE_NOT_CHECK2(T, CODE1, CODE2) (T) 
macro define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T) 
macro define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T) 
macro define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) 
macro define NON_TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T) 
macro define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) 
macro define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T) 
macro define CONTAINS_STRUCT_CHECK(T, STRUCT) (T) 
macro define TREE_CLASS_CHECK(T, CLASS) (T) 
macro define TREE_RANGE_CHECK(T, CODE1, CODE2) (T) 
macro define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T) 
macro define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T) 
macro define EXPR_CHECK(T) (T) 
macro define NON_TYPE_CHECK(T) (T) 
macro define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I]) 
macro define OMP_CLAUSE_ELT_CHECK(T, I) ((T)->omp_clause.ops[I]) 
macro define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I]) 
macro define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I]) 
macro define TREE_CHAIN(T) ((T)->common.chain) 
macro define TREE_TYPE(T) ((T)->common.type) 
macro define RTL_FLAG_CHECK1(N, R, C1) (R)
macro define RTL_FLAG_CHECK2(N, R, C1, C2) (R)
macro define RTL_FLAG_CHECK3(N, R, C1, C2, C3) (R)
macro define RTL_FLAG_CHECK4(N, R, C1, C2, C3, C4) (R)
macro define RTL_FLAG_CHECK5(N, R, C1, C2, C3, C4, C5) (R)
macro define RTL_FLAG_CHECK6(N, R, C1, C2, C3, C4, C5, C6) (R)
macro define RTL_FLAG_CHECK7(N, R, C1, C2, C3, C4, C5, C6, C7) (R)
macro define RTL_FLAG_CHECK8(N, R, C1, C2, C3, C4, C5, C6, C7, C8) (R)

in gdbinit.in.  This gets you 99% of the way there.  The -g3 is annoying, as the
sizes are large, fast machines, nice filesystems and ssd disks or better and
help lesson the cost.  This gives up checking during gdb usage, I've not found
that to be a problem yet.  I think this is fine for release branches and older
software.  For trunk, I do like a _better_ solution, like the first patch in
this thread when it can go in.  :-)

Sign in to reply to this message.

Diego Novillo

On 12-05-15 13:19 , Lawrence Crowl wrote: > The gcc source uses several constructs that ...

11 years, 11 months ago (2012-05-15 23:34:33 UTC) #5

richard.guenther_gmail.com

On Tue, May 15, 2012 at 7:19 PM, Lawrence Crowl <crowl@google.com> wrote: > The gcc ...

11 years, 11 months ago (2012-05-16 09:41:04 UTC) #6

On Tue, May 15, 2012 at 7:19 PM, Lawrence Crowl <crowl@google.com> wrote:
> The gcc source uses several constructs that GDB does not understand.
> This patch corrects some of them.  It affects only compilers built
> with ENABLE_TREE_CHECKING, and hence release compilers are unaffected.
>
> In particular, I change the implementation of CHECK macros using
> __extension__ into macros calling template inline functions.  I do not
> change the accessor macros themselves.
>
> The effect is that it now possible to get useful responses to gdb
> command like
>
>    (gdb) print DECL_FUNCTION_CODE (decl)
>
> To make the feature work, you must define two macros within gdb.
>
>    (gdb) macro define __FILE__ "gdb"
>    (gdb) macro define __LINE__ 1
>
> The reason for these definitions is that gdb does not expand the magic
> preprocessor macros, and then cannot find what it thinks is a regular
> symbol.  (There is now a gdb issue for this problem.)  I added these
> definitions to gdbinit.in.
>
> The inline functions would normally introduce additional lines in a
> sequence of gdb 'step' commands.  To prevent that behavior, I have
> added the new 'skip' command for the "tree.h" file to gdbinit.in.  The
> 'skip' command works with gdb 7.4 and later.
>
> (The better solution to the stepping behavior is a new gdb command.
> See http://sourceware.org/bugzilla/show_bug.cgi?id=12940.)
>
> Tested on x86-64.

What's the reason for templating these functions?  They all take trees as
parameter!?

Richard.

> Index: gcc/ChangeLog.cxx-conversion
>
> 2012-05-15  Lawrence Crowl  <crowl@google.com>
>
>        * tree.h (tree_check): New.
>        (TREE_CHECK): Use inline function above instead of __extension__.
>        (tree_not_check): New.
>        (TREE_NOT_CHECK): Use inline function above instead of __extension__.
>        (tree_check2): New.
>        (TREE_CHECK2): Use inline function above instead of __extension__.
>        (tree_not_check2): New.
>        (TREE_NOT_CHECK2): Use inline function above instead of __extension__.
>        (tree_check3): New.
>        (TREE_CHECK3): Use inline function above instead of __extension__.
>        (tree_not_check3): New.
>        (TREE_NOT_CHECK3): Use inline function above instead of __extension__.
>        (tree_check4): New.
>        (TREE_CHECK4): Use inline function above instead of __extension__.
>        (tree_not_check4): New.
>        (TREE_NOT_CHECK4): Use inline function above instead of __extension__.
>        (tree_check5): New.
>        (TREE_CHECK5): Use inline function above instead of __extension__.
>        (tree_not_check5): New.
>        (TREE_NOT_CHECK5): Use inline function above instead of __extension__.
>        (contains_struct_check): New.
>        (CONTAINS_STRUCT_CHECK): Use inline function above instead of
>        __extension__.
>        (tree_class_check): New.
>        (TREE_CLASS_CHECK): Use inline function above instead of
__extension__.
>        (tree_range_check): New.
>        (TREE_RANGE_CHECK): Use inline function above instead of
__extension__.
>        (omp_clause_subcode_check): New.
>        (OMP_CLAUSE_SUBCODE_CHECK): Use inline function above instead of
>        __extension__.
>        (omp_clause_range_check): New.
>        (OMP_CLAUSE_RANGE_CHECK): Use inline function above instead of
>        __extension__.
>        (expr_check): New.
>        (EXPR_CHECK): Use inline function above instead of __extension__.
>        (non_type_check): New.
>        (NON_TYPE_CHECK): Use inline function above instead of __extension__.
>        (tree_vec_elt_check): New.
>        (TREE_VEC_ELT_CHECK): Use inline function above instead of
>        __extension__.
>        (omp_clause_elt_check): New.
>        (OMP_CLAUSE_ELT_CHECK): Use inline function above instead of
>        __extension__.
>        (tree_operand_check): New.
>        (TREE_OPERAND_CHECK): Use inline function above instead of
>        __extension__.
>        (tree_operand_check_code): New.
>        (TREE_OPERAND_CHECK_CODE): Use inline function above instead of
>        __extension__.
>        (TREE_CHAIN): Simplify implementation.
>        (TREE_TYPE): Simplify implementation.
>        (tree_operand_length): Move for compilation dependences.
>        * gdbinit.in: (macro define __FILE__): New.
>        (macro define __LINE__): New.
>        (skip "tree.h"): New.
>
>
> Index: gcc/tree.h
> ===================================================================
> --- gcc/tree.h  (revision 187477)
> +++ gcc/tree.h  (working copy)
> @@ -727,195 +727,80 @@ enum tree_node_structure_enum {
>    is accessed incorrectly. The macros die with a fatal error.  */
>  #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
>
> -#define TREE_CHECK(T, CODE) __extension__                              \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != (CODE))                                     \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,        \
> -                        (CODE), 0);                                    \
> -    __t; })
> +#define TREE_CHECK(T, CODE) \
> +(tree_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
>
> -#define TREE_NOT_CHECK(T, CODE) __extension__                          \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) == (CODE))                                     \
> -      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,    \
> -                            (CODE), 0);                                \
> -    __t; })
> +#define TREE_NOT_CHECK(T, CODE) \
> +(tree_not_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
>
> -#define TREE_CHECK2(T, CODE1, CODE2) __extension__                     \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != (CODE1)                                     \
> -       && TREE_CODE (__t) != (CODE2))                                  \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,              
 \
> -                        (CODE1), (CODE2), 0);                          \
> -    __t; })
> +#define TREE_CHECK2(T, CODE1, CODE2) \
> +(tree_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
>
> -#define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__                 \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) == (CODE1)                                     \
> -       || TREE_CODE (__t) == (CODE2))                                  \
> -      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,    \
> -                            (CODE1), (CODE2), 0);                      \
> -    __t; })
> +#define TREE_NOT_CHECK2(T, CODE1, CODE2) \
> +(tree_not_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
>
> -#define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__              \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != (CODE1)                                     \
> -       && TREE_CODE (__t) != (CODE2)                                   \
> -       && TREE_CODE (__t) != (CODE3))                                  \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,              
 \
> -                            (CODE1), (CODE2), (CODE3), 0);             \
> -    __t; })
> +#define TREE_CHECK3(T, CODE1, CODE2, CODE3) \
> +(tree_check3 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2),
(CODE3)))
>
> -#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__          \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) == (CODE1)                                     \
> -       || TREE_CODE (__t) == (CODE2)                                   \
> -       || TREE_CODE (__t) == (CODE3))                                  \
> -      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,    \
> -                            (CODE1), (CODE2), (CODE3), 0);             \
> -    __t; })
> +#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) \
> +(tree_not_check3 ((T), __FILE__, __LINE__, __FUNCTION__, \
> +                               (CODE1), (CODE2), (CODE3)))
>
> -#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__       \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != (CODE1)                                     \
> -       && TREE_CODE (__t) != (CODE2)                                   \
> -       && TREE_CODE (__t) != (CODE3)                                   \
> -       && TREE_CODE (__t) != (CODE4))                                  \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,              
 \
> -                            (CODE1), (CODE2), (CODE3), (CODE4), 0);    \
> -    __t; })
> +#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
> +(tree_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
> +                           (CODE1), (CODE2), (CODE3), (CODE4)))
>
> -#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__   \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) == (CODE1)                                     \
> -       || TREE_CODE (__t) == (CODE2)                                   \
> -       || TREE_CODE (__t) == (CODE3)                                   \
> -       || TREE_CODE (__t) == (CODE4))                                  \
> -      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,    \
> -                            (CODE1), (CODE2), (CODE3), (CODE4), 0);    \
> -    __t; })
> +#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
> +(tree_not_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
> +                               (CODE1), (CODE2), (CODE3), (CODE4)))
>
> -#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__      
 \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != (CODE1)                                     \
> -       && TREE_CODE (__t) != (CODE2)                                   \
> -       && TREE_CODE (__t) != (CODE3)                                   \
> -       && TREE_CODE (__t) != (CODE4)                                   \
> -       && TREE_CODE (__t) != (CODE5))                                  \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,              
 \
> -                            (CODE1), (CODE2), (CODE3), (CODE4), (CODE5),
0);\
> -    __t; })
> +#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
> +(tree_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
> +                           (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
>
> -#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__
\
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) == (CODE1)                                     \
> -       || TREE_CODE (__t) == (CODE2)                                   \
> -       || TREE_CODE (__t) == (CODE3)                                   \
> -       || TREE_CODE (__t) == (CODE4)                                   \
> -       || TREE_CODE (__t) == (CODE5))                                  \
> -      tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,    \
> -                            (CODE1), (CODE2), (CODE3), (CODE4), (CODE5),
0);\
> -    __t; })
> +#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
> +(tree_not_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
> +                               (CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
>
> -#define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__                 \
> -({  __typeof (T) const __t = (T);                                      \
> -  if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1)             \
> -      tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__,  
 \
> -                              __FUNCTION__);                           \
> -    __t; })
> +#define CONTAINS_STRUCT_CHECK(T, STRUCT) \
> +(contains_struct_check ((T), (STRUCT), __FILE__, __LINE__, __FUNCTION__))
>
> -#define TREE_CLASS_CHECK(T, CLASS) __extension__                       \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS))                   \
> -      tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__,       \
> -                              __FUNCTION__);                           \
> -    __t; })
> +#define TREE_CLASS_CHECK(T, CLASS) \
> +(tree_class_check ((T), (CLASS), __FILE__, __LINE__, __FUNCTION__))
>
> -#define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__                      
 \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) < (CODE1) || TREE_CODE (__t) > (CODE2))              
 \
> -      tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,  \
> -                              (CODE1), (CODE2));                       \
> -    __t; })
> +#define TREE_RANGE_CHECK(T, CODE1, CODE2) \
> +(tree_range_check ((T), (CODE1), (CODE2), __FILE__, __LINE__, __FUNCTION__))
>
> -#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__                      
 \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != OMP_CLAUSE)                                 \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,        \
> -                        OMP_CLAUSE, 0);                                \
> -    if (__t->omp_clause.code != (CODE))                                      
 \
> -      omp_clause_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,  \
> -                              (CODE));                                 \
> -    __t; })
> +#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) \
> +(omp_clause_subcode_check ((T), (CODE), __FILE__, __LINE__, __FUNCTION__))
>
> -#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__          \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TREE_CODE (__t) != OMP_CLAUSE)                                 \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,        \
> -                        OMP_CLAUSE, 0);                                \
> -    if ((int) __t->omp_clause.code < (int) (CODE1)                     \
> -        || (int) __t->omp_clause.code > (int) (CODE2))                 \
> -      omp_clause_range_check_failed (__t, __FILE__, __LINE__,          \
> -                                    __FUNCTION__, (CODE1), (CODE2));   \
> -    __t; })
> +#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) \
> +(omp_clause_range_check ((T), (CODE1), (CODE2), \
> +                                      __FILE__, __LINE__, __FUNCTION__))
>
>  /* These checks have to be special cased.  */
> -#define EXPR_CHECK(T) __extension__                                    \
> -({  __typeof (T) const __t = (T);                                      \
> -    char const __c = TREE_CODE_CLASS (TREE_CODE (__t));                      
 \
> -    if (!IS_EXPR_CODE_CLASS (__c))                                     \
> -      tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__,      
 \
> -                              __FUNCTION__);                           \
> -    __t; })
> +#define EXPR_CHECK(T) \
> +(expr_check ((T), __FILE__, __LINE__, __FUNCTION__))
>
>  /* These checks have to be special cased.  */
> -#define NON_TYPE_CHECK(T) __extension__                                      
 \
> -({  __typeof (T) const __t = (T);                                      \
> -    if (TYPE_P (__t))                                                  \
> -      tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__,  \
> -                                  __FUNCTION__);                       \
> -    __t; })
> +#define NON_TYPE_CHECK(T) \
> +(non_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
>
> -#define TREE_VEC_ELT_CHECK(T, I) __extension__                         \
> -(*({__typeof (T) const __t = (T);                                      \
> -    const int __i = (I);                                               \
> -    if (TREE_CODE (__t) != TREE_VEC)                                   \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,              
 \
> -                        TREE_VEC, 0);                                  \
> -    if (__i < 0 || __i >= __t->vec.length)                             \
> -      tree_vec_elt_check_failed (__i, __t->vec.length,                 \
> -                                __FILE__, __LINE__, __FUNCTION__);     \
> -    &__t->vec.a[__i]; }))
> +#define TREE_VEC_ELT_CHECK(T, I) \
> +(*(CONST_CAST2 (tree *, typeof (T)*, \
> +     tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
>
> -#define OMP_CLAUSE_ELT_CHECK(T, I) __extension__                       \
> -(*({__typeof (T) const __t = (T);                                      \
> -    const int __i = (I);                                               \
> -    if (TREE_CODE (__t) != OMP_CLAUSE)                                 \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,        \
> -                        OMP_CLAUSE, 0);                                \
> -    if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])   \
> -      omp_clause_operand_check_failed (__i, __t, __FILE__, __LINE__,   \
> -                                      __FUNCTION__);                   \
> -    &__t->omp_clause.ops[__i]; }))
> +#define OMP_CLAUSE_ELT_CHECK(T, I) \
> +(*(omp_clause_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))
>
>  /* Special checks for TREE_OPERANDs.  */
> -#define TREE_OPERAND_CHECK(T, I) __extension__                         \
> -(*({__typeof (T) const __t = EXPR_CHECK (T);                           \
> -    const int __i = (I);                                               \
> -    if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))                   \
> -      tree_operand_check_failed (__i, __t,                             \
> -                                __FILE__, __LINE__, __FUNCTION__);     \
> -    &__t->exp.operands[__i]; }))
> +#define TREE_OPERAND_CHECK(T, I) \
> +(*(CONST_CAST2 (tree*, typeof (T)*, \
> +     tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
>
> -#define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__              \
> -(*({__typeof (T) const __t = (T);                                      \
> -    const int __i = (I);                                               \
> -    if (TREE_CODE (__t) != CODE)                                       \
> -      tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\
> -    if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))                   \
> -      tree_operand_check_failed (__i, __t,                             \
> -                                __FILE__, __LINE__, __FUNCTION__);     \
> -    &__t->exp.operands[__i]; }))
> +#define TREE_OPERAND_CHECK_CODE(T, CODE, I) \
> +(*(tree_operand_check_code ((T), (CODE), (I), \
> +                                         __FILE__, __LINE__, __FUNCTION__)))
>
>  /* Nodes are chained together for many purposes.
>    Types are chained together to record them for being output to the debugger
> @@ -926,17 +811,15 @@ enum tree_node_structure_enum {
>    Often lists of things are represented by TREE_LIST nodes that
>    are chained together.  */
>
> -#define TREE_CHAIN(NODE) __extension__ \
> -(*({__typeof (NODE) const __t = CONTAINS_STRUCT_CHECK (NODE, TS_COMMON);\
> -    &__t->common.chain; }))
> +#define TREE_CHAIN(NODE) \
> +(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)->common.chain)
>
>  /* In all nodes that are expressions, this is the data type of the
expression.
>    In POINTER_TYPE nodes, this is the type that the pointer points to.
>    In ARRAY_TYPE nodes, this is the type of the elements.
>    In VECTOR_TYPE nodes, this is the type of the elements.  */
> -#define TREE_TYPE(NODE) __extension__ \
> -(*({__typeof (NODE) const __t = CONTAINS_STRUCT_CHECK (NODE, TS_TYPED); \
> -    &__t->typed.type; }))
> +#define TREE_TYPE(NODE) \
> +(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)->typed.type)
>
>  extern void tree_contains_struct_check_failed (const_tree,
>                                               const enum
tree_node_structure_enum,
> @@ -3718,6 +3601,273 @@ union GTY ((ptr_alias (union lang_tree_n
>   struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION")))
optimization;
>   struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
>  };
> +
> +
> +#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
> +
> +template <typename Tree>
> +inline Tree
> +tree_check (Tree __t, const char *__f, int __l, const char *__g, tree_code
__c)
> +{
> +  if (TREE_CODE (__t) != __c)
> +    tree_check_failed (__t, __f, __l, __g, __c, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_not_check (Tree __t, const char *__f, int __l, const char *__g,
> +                enum tree_code __c)
> +{
> +  if (TREE_CODE (__t) == __c)
> +    tree_not_check_failed (__t, __f, __l, __g, __c, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_check2 (Tree __t, const char *__f, int __l, const char *__g,
> +             enum tree_code __c1, enum tree_code __c2)
> +{
> +  if (TREE_CODE (__t) != __c1
> +      && TREE_CODE (__t) != __c2)
> +    tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_not_check2 (Tree __t, const char *__f, int __l, const char *__g,
> +                 enum tree_code __c1, enum tree_code __c2)
> +{
> +  if (TREE_CODE (__t) == __c1
> +      || TREE_CODE (__t) == __c2)
> +    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_check3 (Tree __t, const char *__f, int __l, const char *__g,
> +             enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
> +{
> +  if (TREE_CODE (__t) != __c1
> +      && TREE_CODE (__t) != __c2
> +      && TREE_CODE (__t) != __c3)
> +    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_not_check3 (Tree __t, const char *__f, int __l, const char *__g,
> +                 enum tree_code __c1, enum tree_code __c2, enum tree_code
__c3)
> +{
> +  if (TREE_CODE (__t) == __c1
> +      || TREE_CODE (__t) == __c2
> +      || TREE_CODE (__t) == __c3)
> +    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_check4 (Tree __t, const char *__f, int __l, const char *__g,
> +             enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
> +             enum tree_code __c4)
> +{
> +  if (TREE_CODE (__t) != __c1
> +      && TREE_CODE (__t) != __c2
> +      && TREE_CODE (__t) != __c3
> +      && TREE_CODE (__t) != __c4)
> +    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_not_check4 (Tree __t, const char *__f, int __l, const char *__g,
> +                 enum tree_code __c1, enum tree_code __c2, enum tree_code
__c3,
> +                 enum tree_code __c4)
> +{
> +  if (TREE_CODE (__t) == __c1
> +      || TREE_CODE (__t) == __c2
> +      || TREE_CODE (__t) == __c3
> +      || TREE_CODE (__t) == __c4)
> +    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_check5 (Tree __t, const char *__f, int __l, const char *__g,
> +             enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
> +             enum tree_code __c4, enum tree_code __c5)
> +{
> +  if (TREE_CODE (__t) != __c1
> +      && TREE_CODE (__t) != __c2
> +      && TREE_CODE (__t) != __c3
> +      && TREE_CODE (__t) != __c4
> +      && TREE_CODE (__t) != __c5)
> +    tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_not_check5 (Tree __t, const char *__f, int __l, const char *__g,
> +                 enum tree_code __c1, enum tree_code __c2, enum tree_code
__c3,
> +                 enum tree_code __c4, enum tree_code __c5)
> +{
> +  if (TREE_CODE (__t) == __c1
> +      || TREE_CODE (__t) == __c2
> +      || TREE_CODE (__t) == __c3
> +      || TREE_CODE (__t) == __c4
> +      || TREE_CODE (__t) == __c5)
> +    tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
0);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +contains_struct_check (Tree __t, const enum tree_node_structure_enum __s,
> +                       const char *__f, int __l, const char *__g)
> +{
> +  if (tree_contains_struct[TREE_CODE(__t)][__s] != 1)
> +      tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_class_check (Tree __t, const enum tree_code_class __class,
> +                  const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE_CLASS (TREE_CODE(__t)) != __class)
> +    tree_class_check_failed (__t, __class, __f, __l, __g);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +tree_range_check (Tree __t,
> +                  enum tree_code __code1, enum tree_code __code2,
> +                  const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
> +    tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +omp_clause_subcode_check (Tree __t, enum omp_clause_code __code,
> +                          const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE (__t) != OMP_CLAUSE)
> +    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
> +  if (__t->omp_clause.code != __code)
> +    omp_clause_check_failed (__t, __f, __l, __g, __code);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline Tree
> +omp_clause_range_check (Tree __t,
> +                        enum omp_clause_code __code1,
> +                        enum omp_clause_code __code2,
> +                        const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE (__t) != OMP_CLAUSE)
> +    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
> +  if ((int) __t->omp_clause.code < (int) __code1
> +      || (int) __t->omp_clause.code > (int) __code2)
> +    omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
> +  return __t;
> +}
> +
> +/* These checks have to be special cased.  */
> +template <typename Tree>
> +inline Tree
> +expr_check (Tree __t, const char *__f, int __l, const char *__g)
> +{
> +  char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
> +  if (!IS_EXPR_CODE_CLASS (__c))
> +    tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
> +  return __t;
> +}
> +
> +/* These checks have to be special cased.  */
> +template <typename Tree>
> +inline Tree
> +non_type_check (Tree __t, const char *__f, int __l, const char *__g)
> +{
> +  if (TYPE_P (__t))
> +    tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
> +  return __t;
> +}
> +
> +template <typename Tree>
> +inline tree *
> +tree_vec_elt_check (Tree __t, int __i,
> +                    const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE (__t) != TREE_VEC)
> +    tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
> +  if (__i < 0 || __i >= __t->vec.length)
> +    tree_vec_elt_check_failed (__i, __t->vec.length, __f, __l, __g);
> +  return &CONST_CAST_TREE (__t)->vec.a[__i];
> +}
> +
> +template <typename Tree>
> +inline Tree *
> +omp_clause_elt_check (Tree __t, int __i,
> +                      const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE (__t) != OMP_CLAUSE)
> +    tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
> +  if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
> +    omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
> +  return &__t->omp_clause.ops[__i];
> +}
> +
> +/* Compute the number of operands in an expression node NODE.  For
> +   tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
> +   otherwise it is looked up from the node's code.  */
> +static inline int
> +tree_operand_length (const_tree node)
> +{
> +  if (VL_EXP_CLASS_P (node))
> +    return VL_EXP_OPERAND_LENGTH (node);
> +  else
> +    return TREE_CODE_LENGTH (TREE_CODE (node));
> +}
> +
> +/* Special checks for TREE_OPERANDs.  */
> +template <typename Tree>
> +inline tree *
> +tree_operand_check (Tree __t, int __i,
> +                    const char *__f, int __l, const char *__g)
> +{
> +  const_tree __u = EXPR_CHECK (__t);
> +  if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
> +    tree_operand_check_failed (__i, __u, __f, __l, __g);
> +  return &CONST_CAST_TREE (__u)->exp.operands[__i];
> +}
> +
> +template <typename Tree>
> +inline Tree *
> +tree_operand_check_code (Tree __t, enum tree_code __code, int __i,
> +                         const char *__f, int __l, const char *__g)
> +{
> +  if (TREE_CODE (__t) != __code)
> +    tree_check_failed (__t, __f, __l, __g, __code, 0);
> +  if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
> +    tree_operand_check_failed (__i, __t, __f, __l, __g);
> +  return &__t->exp.operands[__i];
> +}
> +
> +#endif
>
>  /* Standard named or nameless data types of the C compiler.  */
>
> @@ -5895,18 +6045,6 @@ is_tm_safe_or_pure (const_tree x)
>
>  void init_inline_once (void);
>
> -/* Compute the number of operands in an expression node NODE.  For
> -   tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
> -   otherwise it is looked up from the node's code.  */
> -static inline int
> -tree_operand_length (const_tree node)
> -{
> -  if (VL_EXP_CLASS_P (node))
> -    return VL_EXP_OPERAND_LENGTH (node);
> -  else
> -    return TREE_CODE_LENGTH (TREE_CODE (node));
> -}
> -
>  /* Abstract iterators for CALL_EXPRs.  These static inline definitions
>    have to go towards the end of tree.h so that union tree_node is fully
>    defined by this point.  */
> Index: gcc/gdbinit.in
> ===================================================================
> --- gcc/gdbinit.in      (revision 187477)
> +++ gcc/gdbinit.in      (working copy)
> @@ -182,6 +182,14 @@ document pbm
>  Dump the bitmap that is in $ as a comma-separated list of numbers.
>  end
>
> +# Define some macros helpful to gdb when it is expanding macros.
> +macro define __FILE__ "gdb"
> +macro define __LINE__ 1
> +
> +# Skip all inline functions in tree.h.
> +# These are used in accessor macros.
> +skip "tree.h"
> +
>  # Put breakpoints at exit and fancy_abort in case abort is mapped
>  # to either fprintf/exit or fancy_abort.
>  b fancy_abort
>
> --
> This patch is available for review at http://codereview.appspot.com/6188088

Sign in to reply to this message.

Diego Novillo

On 12-05-16 05:41 , Richard Guenther wrote: > What's the reason for templating these functions? ...

11 years, 11 months ago (2012-05-16 12:43:25 UTC) #7

richard.guenther_gmail.com

On Wed, May 16, 2012 at 2:43 PM, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-16 ...

11 years, 11 months ago (2012-05-16 13:00:49 UTC) #8

Diego Novillo

On 12-05-16 09:00 , Richard Guenther wrote: > On Wed, May 16, 2012 at 2:43 ...

11 years, 11 months ago (2012-05-16 13:16:28 UTC) #9

richard.guenther_gmail.com

On Wed, May 16, 2012 at 3:16 PM, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-16 ...

11 years, 11 months ago (2012-05-16 13:27:35 UTC) #10

On Wed, May 16, 2012 at 3:16 PM, Diego Novillo <dnovillo@google.com> wrote:
> On 12-05-16 09:00 , Richard Guenther wrote:
>>
>> On Wed, May 16, 2012 at 2:43 PM, Diego Novillo<dnovillo@google.com>
>>  wrote:
>>>
>>> On 12-05-16 05:41 , Richard Guenther wrote:
>>>
>>>> What's the reason for templating these functions?  They all take trees
>>>> as
>>>> parameter!?
>>>
>>>
>>>
>>> True.  I don't recall what Lawrence had in mind, but I remember that by
>>> using templates here, you don't need to deal with the mess of
>>> distinguishing
>>> tree from const_tree, and having to force constness out with ugly casts.
>>
>>
>> Well, but you get no typesafety for it in return.  You can simply provide
>> a const_tree overload.
>
>
> There's less typing if you use the template variant.  Not sure why you say
> there is less type safety with templates.

Because it accepts any type as tree argument?  It's of course not less
type safety than using macros, but less type safety compared to not
using templates.

>> With using templates you are also forced to retain
>> these functions in the header file - another thing that I suppose you guys
>> were about to "fix"?  It's after all debugging code.
>
>
> No, templated functions must always stay in the header file.  There is no
> changing that.

If they ain't templates they are not templates.  And thus do not need to
stay in the header.  Not sure what you are after here ;)

>>> Additionally, templates are producing slightly smaller code than the
>>> non-template variant (about 0.2% smaller).  I'm not actually sure why
>>> this
>>> happens, but it's consistent across all binaries.
>>
>>
>> Well, what did you compare?  Make sure to not have
>> -fkeep-inline-functions,
>> otherwise you get all bodies as compared to only the instantiated bodies.
>
>
> Two bootstrapped compilers built exactly the same, except one was using the
> template version, the other using the straight inline functions with
> const_tree parameters and CONST_CAST_TREE in return values.

That's of course not exactly the same.  The checking fns should be able
to unconditionally use const_tree anyway.

Richard.

>
> Diego.

Sign in to reply to this message.

Diego Novillo

On 12-05-16 09:27 , Richard Guenther wrote: >> There's less typing if you use the ...

11 years, 11 months ago (2012-05-16 13:40:40 UTC) #11

richard.guenther_gmail.com

On Wed, May 16, 2012 at 3:40 PM, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-16 ...

11 years, 11 months ago (2012-05-16 13:46:23 UTC) #12

On Wed, May 16, 2012 at 3:40 PM, Diego Novillo <dnovillo@google.com> wrote:
> On 12-05-16 09:27 , Richard Guenther wrote:
>
>>> There's less typing if you use the template variant.  Not sure why
>>> you say there is less type safety with templates.
>>
>>
>> Because it accepts any type as tree argument?
>
>
> Yes and no.  It accepts any type that responds to tree
> operations and has the same fields.
>
>
>>> No, templated functions must always stay in the header file.
>>> There is no changing that.
>>
>>
>> If they ain't templates they are not templates.  And thus do not
>> need to stay in the header.  Not sure what you are after here ;)
>
>
> I think we are talking past each other.  I simply stated that function
> templates must stay in headers.  There's no export template, after all.
>
> I'm not defending the choice of using templates for these particular
> functions.  That's something for Lawrence to argue.
>
> I am simply curious as to how using the template variant produces
> slightly smaller code.
>
>
>>> Two bootstrapped compilers built exactly the same, except one was
>>> using the template version, the other using the straight inline
>>> functions with const_tree parameters and CONST_CAST_TREE in return
>>> values.
>>
>>
>> That's of course not exactly the same.  The checking fns should be
>> able to unconditionally use const_tree anyway.
>
>
> Sorry, I don't know what you are after.  I was comparing two compilers
> that only differ in how they implement the tree checking functions.  One
> uses templates, the other uses inline functions taking const_tree (not even
> static inline, just inline).
>
> They are bootstrapped compilers, so -fkeep-inline-functions is not used.
> What do you think I should have compared?

Sounds like it should come out equally sized then.  Possibly an instantiated
template leads to different code from the frontend?  Possibly we do not inline
all calls in either case?  Possibly because only instantiated templates count
towards initial unit size (but all, even unused(?), inline functions
count towards
it)?

Would be interesting to see preprocessed source for both cases for a
single object files where the size difference appears.  It might be
artificial, too,
caused by UID perturbations and random codegen difference due to that.

Non-templates should use less memory (with templates you at least have
a single instantiation and thus copy of the functions, with functions you
just have one).

That said - I see no technical reasons to use templates here and we should
not use C++ just because we can ... (and not scare people off here if the
technical reason is minor, such as an unknown size advantage).

Richard.

>
> Diego.

Sign in to reply to this message.

bonzini_gnu.org

Il 16/05/2012 15:27, Richard Guenther ha scritto: >> > >> > Two bootstrapped compilers built ...

11 years, 11 months ago (2012-05-16 15:54:22 UTC) #13

tromey_redhat.com

>>>>> "Lawrence" == Lawrence Crowl <crowl@google.com> writes: Lawrence> The effect is that it now possible ...

11 years, 11 months ago (2012-05-16 18:13:38 UTC) #14

Lawrence Crowl

On 5/16/12, Richard Guenther <richard.guenther@gmail.com> wrote: > On May 16, 2012 Diego Novillo <dnovillo@google.com> wrote: ...

11 years, 11 months ago (2012-05-16 20:44:53 UTC) #15

On 5/16/12, Richard Guenther <richard.guenther@gmail.com> wrote:
> On May 16, 2012 Diego Novillo <dnovillo@google.com> wrote:
> > On 12-05-16 09:00 , Richard Guenther wrote:
> > > On May 16, 2012 Diego Novillo<dnovillo@google.com> wrote:
> > > > On 12-05-16 05:41 , Richard Guenther wrote:
> > > > > What's the reason for templating these functions?
> > > > > They all take trees as parameter!?

The check templates replicate the behavior of the check macros,
which carefully return the type of their argument.  In essence,
the check macros were templates.

> > > > True.  I don't recall what Lawrence had in mind, but I
> > > > remember that by using templates here, you don't need to
> > > > deal with the mess of distinguishing tree from const_tree,
> > > > and having to force constness out with ugly casts.
> > >
> > > Well, but you get no typesafety for it in return.  You can
> > > simply provide a const_tree overload.
> >
> > There's less typing if you use the template variant.  Not sure
> > why you say there is less type safety with templates.
>
> Because it accepts any type as tree argument?  It's of course not
> less type safety than using macros, but less type safety compared
> to not using templates.

The overload works if the only types are tree and const_tree.
In the future, we may wish to refine the types so that, for example,
we can have a pointer to a decl and ask if it is a var decl.

The implementation approach is to make small steps.  It's a tradeoff
between small steps that may show only incremental value, or big
steps that risk rejection.  In addition, merging is easier with
small steps.

> > > With using templates you are also forced to retain these
> > > functions in the header file - another thing that I suppose
> > > you guys were about to "fix"?  It's after all debugging code.
> >
> > No, templated functions must always stay in the header file.
> > There is no changing that.
>
> If they ain't templates they are not templates.  And thus do not
> need to stay in the header.  Not sure what you are after here ;)

Personally, I would like to get to the point where we take advantage
of static typing and the vast bulk of these checks are eliminated.

> > > > Additionally, templates are producing slightly smaller
> > > > code than the non-template variant (about 0.2% smaller).
> > > > I'm not actually sure why this happens, but it's consistent
> > > > across all binaries.
> > >
> > > Well, what did you compare?  Make sure to not have
> > > -fkeep-inline-functions, otherwise you get all bodies as
> > > compared to only the instantiated bodies.
> >
> > Two bootstrapped compilers built exactly the same, except one
> > was using the template version, the other using the straight
> > inline functions with const_tree parameters and CONST_CAST_TREE
> > in return values.
>
> That's of course not exactly the same.  The checking fns should
> be able to unconditionally use const_tree anyway.

The two versions are inline templates functions versus macros.
I expect the non-template version would be roughly the same size
as the template version.

-- 
Lawrence Crowl

Sign in to reply to this message.

Lawrence Crowl

On 5/16/12, Tom Tromey <tromey@redhat.com> wrote: >>>>>> "Lawrence" == Lawrence Crowl <crowl@google.com> writes: > > ...

11 years, 11 months ago (2012-05-16 20:57:04 UTC) #16

matz_suse.de

Hi, On Wed, 16 May 2012, Lawrence Crowl wrote: > > Because it accepts any ...

11 years, 11 months ago (2012-05-17 14:52:16 UTC) #17

Diego Novillo

On 12-05-17 10:52 , Michael Matz wrote: > Cross the bridge when you reach it, ...

11 years, 11 months ago (2012-05-17 18:36:05 UTC) #18

On 12-05-17 10:52 , Michael Matz wrote:

> Cross the bridge when you reach it, not before.  Not everybody agrees that
> the splitting of tree would be a good idea.  Right now templates aren't
> necessary, so you shouldn't use them.  (well, and an investigation why
> they come up with smaller .text would be in order anyway).

I've been playing around with this patch a little bit.  The main 
motivation for using templates here is to preserve the existing 
semantics.  Note that the return type from the function mimics the type 
of the argument passed in.  So, if the user passes a const_tree, the 
function returns a const_tree.

The way to do this in C++ is to: (a) use templates (as in Lawrence's 
patch), or (b) produce overloaded variants for tree and const_tree.

For trunk, we have a third option: (c) make these functions out-of-line 
functions that take const_tree and return tree.  This slightly weakens 
the semantics of the checks, but it does not rely on C++ features.

Options (a) or (b) are the same to me.  Option (b) has the slight 
advantage that the code can be taken out of tree.h and buried in tree.c.

The attached patch implements option (c).  Should we consider this for 
trunk now and then just replace the CONST_CAST_TREE into C++ overloads?


Thanks.  Diego.


2012-05-17  Lawrence Crowl  <crowl@google.com>

         * tree.h (tree_check): Declare.
         (TREE_CHECK): Use function above instead of __extension__.
         (tree_not_check): Declare.
         (TREE_NOT_CHECK): Use function above instead of __extension__.
         (tree_check2): Declare.
         (TREE_CHECK2): Use function above instead of __extension__.
         (tree_not_check2): Declare.
         (TREE_NOT_CHECK2): Use function above instead of __extension__.
         (tree_check3): Declare.
         (TREE_CHECK3): Use function above instead of __extension__.
         (tree_not_check3): Declare.
         (TREE_NOT_CHECK3): Use function above instead of __extension__.
         (tree_check4): Declare.
         (TREE_CHECK4): Use function above instead of __extension__.
         (tree_not_check4): Declare.
         (TREE_NOT_CHECK4): Use function above instead of __extension__.
         (tree_check5): Declare.
         (TREE_CHECK5): Use function above instead of __extension__.
         (tree_not_check5): Declare.
         (TREE_NOT_CHECK5): Use function above instead of __extension__.
         (contains_struct_check): Declare.
         (CONTAINS_STRUCT_CHECK): Use function above instead of
         __extension__.
         (tree_class_check): Declare.
         (TREE_CLASS_CHECK): Use function above instead of __extension__.
         (tree_range_check): Declare.
         (TREE_RANGE_CHECK): Use function above instead of __extension__.
         (omp_clause_subcode_check): Declare.
         (OMP_CLAUSE_SUBCODE_CHECK): Use function above instead of
         __extension__.
         (omp_clause_range_check): Declare.
         (OMP_CLAUSE_RANGE_CHECK): Use function above instead of
         __extension__.
         (expr_check): Declare.
         (EXPR_CHECK): Use function above instead of __extension__.
         (non_type_check): Declare.
         (NON_TYPE_CHECK): Use function above instead of __extension__.
         (tree_vec_elt_check): Declare.
         (TREE_VEC_ELT_CHECK): Use function above instead of
         __extension__.
         (omp_clause_elt_check): Declare.
         (OMP_CLAUSE_ELT_CHECK): Use function above instead of
         __extension__.
         (tree_operand_check): Declare.
         (TREE_OPERAND_CHECK): Use function above instead of
         __extension__.
         (tree_operand_check_code): Declare.
         (TREE_OPERAND_CHECK_CODE): Use function above instead of
         __extension__.
         (TREE_CHAIN): Simplify implementation.
         (TREE_TYPE): Simplify implementation.
         (tree_operand_length): Move for compilation dependences.
         * tree.c (tree_check): New.
         (tree_not_check): New.
         (tree_check2): New.
         (tree_not_check2): New.
         (tree_check3): New.
         (tree_not_check3): New.
         (tree_check4): New.
         (tree_not_check4): New.
         (tree_check5): New.
         (tree_not_check5): New.
         (contains_struct_check): New.
         (tree_range_check): New.
         (omp_clause_subcode_check): New.
         (omp_clause_range_check): New.
         (expr_check): New.
         (non_type_check): New.
         (tree_vec_elt_check): New.
         (omp_clause_elt_check): New.
         (tree_operand_check): New.
         (tree_operand_check_code): New.
         * gdbinit.in: (macro define __FILE__): New.
         (macro define __LINE__): New.
         (skip "tree.h"): New.

Sign in to reply to this message.

tromey_redhat.com

>>>>> "Lawrence" == Lawrence Crowl <crowl@google.com> writes: Tom> Doesn't this mean that if you have ...

11 years, 11 months ago (2012-05-17 20:53:29 UTC) #19

pinskia_gmail.com

On Thu, May 17, 2012 at 1:53 PM, Tom Tromey <tromey@redhat.com> wrote: >>>>>> "Lawrence" == ...

11 years, 11 months ago (2012-05-17 21:05:27 UTC) #20

Lawrence Crowl

On 5/17/12, Tom Tromey <tromey@redhat.com> wrote: > > "Lawrence" == Lawrence Crowl <crowl@google.com> writes: > ...

11 years, 11 months ago (2012-05-17 21:41:41 UTC) #21

mikestump_comcast.net

On May 17, 2012, at 2:41 PM, Lawrence Crowl wrote: >> Reusing the compiler for ...

11 years, 11 months ago (2012-05-17 23:40:18 UTC) #22

On May 17, 2012, at 2:41 PM, Lawrence Crowl wrote:
>> Reusing the compiler for this seems like the only way to go.
>> But, we did look at using g++ to parse C++ expressions from gdb,
>> and it was too slow :-(.  We're going to look again, at least to
>> generate some bug reports if we can.
> 
> It's a tough problem, particularly as C/C++ and their compilers
> were not designed for a read-eval-print-loop environment.

This of course is trivial to do, and reasonably fast as well.  We have an
existence proof that they can generate a call on the target system, all one
needs to do would be to locate the target compiler, compile up a strapping
routine, push a dlopen of that routine onto the target system and then call
dlsym to grab a handle to it.  The strapping routine can set up an environment
and communication channels as needed.  If could even allocate a thread and have
it always be live (non-stop), if one wanted.

Oh, and the benefit, the language supported by the code closely matches the
compiler.  Speed, 1/40 of a second, fast enough for command like use.  Want to
evaluate it 1000000 times, sure, just be sure to cache the dlopen/dlsym, and
notice that you can do a million invocations, well, I'd guess a million times
faster than gdb currently.

If gdb won't solve these problem, dump it, move to lldb, I can assure you, they
will not fail to solve the problem, just because gdb can't or won't.  The name
of the game is compete or die.

If you use the clang libraries, you can read eval, print... and the performance
would likely be even better.  After all, it can be used to do OpenCL style
programming, and that certainly was built for speed.  So, I reject the idea this
all isn't trivial.

$ cat eval.c
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <sys/time.h>

int main() {
  char buf[4096];
  while (fgets (buf, sizeof (buf), stdin) != NULL) {
    struct timeval tv1, tv2;
    gettimeofday(&tv1, 0);
    FILE *fp = popen ("gcc -w -xc - -shared -o test.so", "w");
    if (fputs (buf, fp) < 0) {
      printf ("write fails\n");
      exit (1);
    }
    if (pclose (fp) != 0) {
      printf ("compile fails\n");
      exit (1);
    }      
    void *vp = dlopen("test.so", RTLD_NOW|RTLD_LOCAL|RTLD_FIRST);
    void *fcn = dlsym (vp, "eval");
    if (fcn) {
      void (*func)();
      func = fcn;
      printf("about to run\n");
      func();
      gettimeofday(&tv2, 0);
      printf("done running, took %ld usecs\n", tv2.tv_sec*1000000 + tv2.tv_usec
- tv1.tv_sec*1000000 - tv1.tv_usec);
    } else {
      printf ("eval not found\n");
    }
    if (dlclose (vp) < 0) {
      printf ("dlclose fails\n");
      exit (1);
    }      

  }
}
$ gcc eval.c -o eval -O3
$ ./eval
int eval () { printf ("hi\n"); }
about to run
hi
done running, took 28419 usecs
int eval () { printf ("hi\n"); }
about to run
hi
done running, took 29300 usecs
int eval () { printf ("hi\n"); }
about to run
hi
done running, took 25755 usecs
int eval () { printf ("hi\n"); }
about to run
hi
done running, took 28295 usecs

Maybe your thinking of lisp, certainly that language makes it hard.  ;-P

Sign in to reply to this message.

richard.guenther_gmail.com

On Thu, May 17, 2012 at 8:36 PM, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-17 ...

11 years, 11 months ago (2012-05-18 10:14:50 UTC) #23

On Thu, May 17, 2012 at 8:36 PM, Diego Novillo <dnovillo@google.com> wrote:
> On 12-05-17 10:52 , Michael Matz wrote:
>
>> Cross the bridge when you reach it, not before.  Not everybody agrees that
>> the splitting of tree would be a good idea.  Right now templates aren't
>> necessary, so you shouldn't use them.  (well, and an investigation why
>> they come up with smaller .text would be in order anyway).
>
>
> I've been playing around with this patch a little bit.  The main motivation
> for using templates here is to preserve the existing semantics.  Note that
> the return type from the function mimics the type of the argument passed in.
>  So, if the user passes a const_tree, the function returns a const_tree.
>
> The way to do this in C++ is to: (a) use templates (as in Lawrence's patch),
> or (b) produce overloaded variants for tree and const_tree.
>
> For trunk, we have a third option: (c) make these functions out-of-line
> functions that take const_tree and return tree.  This slightly weakens the
> semantics of the checks, but it does not rely on C++ features.
>
> Options (a) or (b) are the same to me.  Option (b) has the slight advantage
> that the code can be taken out of tree.h and buried in tree.c.
>
> The attached patch implements option (c).  Should we consider this for trunk
> now and then just replace the CONST_CAST_TREE into C++ overloads?

As you retain the macros anyway you can simply not return anything
from the C++ checking functions define to a stmt expression
({ check_in_cxx (t); t; })

Btw, what breaks if the check functions always return a const_tree and
take a const_tree?

Richard.

>
> Thanks.  Diego.
>
>
> 2012-05-17  Lawrence Crowl  <crowl@google.com>
>
>        * tree.h (tree_check): Declare.
>        (TREE_CHECK): Use function above instead of __extension__.
>        (tree_not_check): Declare.
>        (TREE_NOT_CHECK): Use function above instead of __extension__.
>        (tree_check2): Declare.
>        (TREE_CHECK2): Use function above instead of __extension__.
>        (tree_not_check2): Declare.
>        (TREE_NOT_CHECK2): Use function above instead of __extension__.
>        (tree_check3): Declare.
>        (TREE_CHECK3): Use function above instead of __extension__.
>        (tree_not_check3): Declare.
>        (TREE_NOT_CHECK3): Use function above instead of __extension__.
>        (tree_check4): Declare.
>        (TREE_CHECK4): Use function above instead of __extension__.
>        (tree_not_check4): Declare.
>        (TREE_NOT_CHECK4): Use function above instead of __extension__.
>        (tree_check5): Declare.
>        (TREE_CHECK5): Use function above instead of __extension__.
>        (tree_not_check5): Declare.
>        (TREE_NOT_CHECK5): Use function above instead of __extension__.
>        (contains_struct_check): Declare.
>        (CONTAINS_STRUCT_CHECK): Use function above instead of
>        __extension__.
>        (tree_class_check): Declare.
>        (TREE_CLASS_CHECK): Use function above instead of __extension__.
>        (tree_range_check): Declare.
>        (TREE_RANGE_CHECK): Use function above instead of __extension__.
>        (omp_clause_subcode_check): Declare.
>        (OMP_CLAUSE_SUBCODE_CHECK): Use function above instead of
>        __extension__.
>        (omp_clause_range_check): Declare.
>        (OMP_CLAUSE_RANGE_CHECK): Use function above instead of
>        __extension__.
>        (expr_check): Declare.
>        (EXPR_CHECK): Use function above instead of __extension__.
>        (non_type_check): Declare.
>        (NON_TYPE_CHECK): Use function above instead of __extension__.
>        (tree_vec_elt_check): Declare.
>        (TREE_VEC_ELT_CHECK): Use function above instead of
>        __extension__.
>        (omp_clause_elt_check): Declare.
>        (OMP_CLAUSE_ELT_CHECK): Use function above instead of
>        __extension__.
>        (tree_operand_check): Declare.
>        (TREE_OPERAND_CHECK): Use function above instead of
>        __extension__.
>        (tree_operand_check_code): Declare.
>        (TREE_OPERAND_CHECK_CODE): Use function above instead of
>
>        __extension__.
>        (TREE_CHAIN): Simplify implementation.
>        (TREE_TYPE): Simplify implementation.
>        (tree_operand_length): Move for compilation dependences.
>        * tree.c (tree_check): New.
>        (tree_not_check): New.
>        (tree_check2): New.
>        (tree_not_check2): New.
>        (tree_check3): New.
>        (tree_not_check3): New.
>        (tree_check4): New.
>        (tree_not_check4): New.
>        (tree_check5): New.
>        (tree_not_check5): New.
>        (contains_struct_check): New.
>        (tree_range_check): New.
>        (omp_clause_subcode_check): New.
>        (omp_clause_range_check): New.
>        (expr_check): New.
>        (non_type_check): New.
>        (tree_vec_elt_check): New.
>        (omp_clause_elt_check): New.
>        (tree_operand_check): New.
>        (tree_operand_check_code): New.
>
>        * gdbinit.in: (macro define __FILE__): New.
>        (macro define __LINE__): New.
>        (skip "tree.h"): New.

Sign in to reply to this message.

Diego Novillo

On 12-05-18 06:14 , Richard Guenther wrote: > As you retain the macros anyway you ...

11 years, 11 months ago (2012-05-18 11:46:34 UTC) #24

richard.guenther_gmail.com

On Fri, May 18, 2012 at 1:46 PM, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-18 ...

11 years, 11 months ago (2012-05-18 12:06:19 UTC) #25

jay.foad_gmail.com

On 18 May 2012 12:46, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-18 06:14 , Richard ...

11 years, 11 months ago (2012-05-18 12:23:46 UTC) #26

rth_redhat.com

On 05/18/12 05:06, Richard Guenther wrote: > Can you locate those? I mean, most uses ...

11 years, 11 months ago (2012-05-18 22:14:58 UTC) #27

Diego Novillo

On 12-05-18 18:14 , Richard Henderson wrote: > On 05/18/12 05:06, Richard Guenther wrote: >> ...

11 years, 11 months ago (2012-05-18 23:48:06 UTC) #28

On 12-05-18 18:14 , Richard Henderson wrote:
> On 05/18/12 05:06, Richard Guenther wrote:
>> Can you locate those?  I mean, most uses look like
>>
>> #define DECL_NONSHAREABLE(NODE) \
>>    (TREE_CHECK2 (NODE, VAR_DECL, \
>>                  RESULT_DECL)->decl_common.decl_nonshareable_flag)
>>
>> thus they only dereference the result, not assign it anywhere.
>
> const_tree vs tree for NODE is the difference between the
> entire expression being writable, or read-only.
>
>    DECL_NONSHARABLE (d) = true;

Right.  Returning a const_tree means that you can't write to anything in 
the resulting value.  To answer richi's original question, this produces 
~9,000 syntax errors in gcc/*.o.

So, I would like to figure out what to do with this.   We have a 
usability problem wrt deubgging that I would like to fix.  The only way 
we have of using all the tree accessor macros from GDB is to convert the 
checks into functions (converting the actual accessor macros would also 
work, but that's a different story).

Now that we have the ability to skip functions in gdb, making tree 
checking into functions should not be a problem.  Additionally, we can 
make gdb skip other common functions (like tree_code_length).

We can do this in trunk today using a variant of Lawrence's original 
patch (http://gcc.gnu.org/ml/gcc-patches/2011-09/msg01649.html).  This 
uses no C++ features, though it weakens type checking by removing away 
constness.

In the cxx-conversion branch, we can use overloads, which will DTRT with 
const.

My question is, what do folks prefer?

a) The trunk patch today, using no C++ features.
b) Wait for the cxx-conversion variant?

Incidentally, making these expression statements into out-of-line 
functions saves about 3% in the final binary size, but increases compile 
time by about 10% (tested on several large .o files in bld/gcc), so we 
likely want to keep them as inline functions.

Diego.

Sign in to reply to this message.

Diego Novillo

On 12-05-18 08:23 , Jay Foad wrote: > What's wrong with: > > (check_in_cxx(t), t) ...

11 years, 11 months ago (2012-05-19 00:00:59 UTC) #29

Lawrence Crowl

On 5/17/12, Mike Stump <mikestump@comcast.net> wrote: > On May 17, 2012, at 2:41 PM, Lawrence ...

11 years, 11 months ago (2012-05-19 02:48:28 UTC) #30

On 5/17/12, Mike Stump <mikestump@comcast.net> wrote:
> On May 17, 2012, at 2:41 PM, Lawrence Crowl wrote:
>>> Reusing the compiler for this seems like the only way to go.
>>> But, we did look at using g++ to parse C++ expressions from gdb,
>>> and it was too slow :-(.  We're going to look again, at least to
>>> generate some bug reports if we can.
>>
>> It's a tough problem, particularly as C/C++ and their compilers
>> were not designed for a read-eval-print-loop environment.
>
> This of course is trivial to do,

I do not think that word means what you think it means.  :-)

> and reasonably fast as well.  We have an existence proof that
> they can generate a call on the target system, all one needs to
> do would be to locate the target compiler, compile up a strapping
> routine, push a dlopen of that routine onto the target system and
> then call dlsym to grab a handle to it.  The strapping routine
> can set up an environment and communication channels as needed.
> If could even allocate a thread and have it always be live
> (non-stop), if one wanted.

I agree that it is possible.

> Oh, and the benefit, the language supported by the code closely
> matches the compiler.  Speed, 1/40 of a second, fast enough for
> command like use.  Want to evaluate it 1000000 times, sure, just
> be sure to cache the dlopen/dlsym, and notice that you can do a
> million invocations, well, I'd guess a million times faster than
> gdb currently.

Agree.

> If gdb won't solve these problem, dump it, move to lldb, I can
> assure you, they will not fail to solve the problem, just because
> gdb can't or won't.  The name of the game is compete or die.
>
> If you use the clang libraries, you can read eval, print... and
> the performance would likely be even better.  After all, it can
> be used to do OpenCL style programming, and that certainly was
> built for speed.  So, I reject the idea this all isn't trivial.

Yes, clang was designed to handle this use case.

>
> $ cat eval.c
> #include <stdio.h>
> #include <stdlib.h>
> #include <dlfcn.h>
> #include <sys/time.h>
>
> int main() {
>   char buf[4096];
>   while (fgets (buf, sizeof (buf), stdin) != NULL) {
>     struct timeval tv1, tv2;
>     gettimeofday(&tv1, 0);
>     FILE *fp = popen ("gcc -w -xc - -shared -o test.so", "w");
>     if (fputs (buf, fp) < 0) {
>       printf ("write fails\n");
>       exit (1);
>     }
>     if (pclose (fp) != 0) {
>       printf ("compile fails\n");
>       exit (1);
>     }
>     void *vp = dlopen("test.so", RTLD_NOW|RTLD_LOCAL|RTLD_FIRST);
>     void *fcn = dlsym (vp, "eval");
>     if (fcn) {
>       void (*func)();
>       func = fcn;
>       printf("about to run\n");
>       func();
>       gettimeofday(&tv2, 0);
>       printf("done running, took %ld usecs\n", tv2.tv_sec*1000000
>              + tv2.tv_usec - tv1.tv_sec*1000000 - tv1.tv_usec);
>     } else {
>       printf ("eval not found\n");
>     }
>     if (dlclose (vp) < 0) {
>       printf ("dlclose fails\n");
>       exit (1);
>     }
>   }
> }
> $ gcc eval.c -o eval -O3
> $ ./eval
> int eval () { printf ("hi\n"); }
> about to run
> hi
> done running, took 28419 usecs
> int eval () { printf ("hi\n"); }
> about to run
> hi
> done running, took 29300 usecs
> int eval () { printf ("hi\n"); }
> about to run
> hi
> done running, took 25755 usecs
> int eval () { printf ("hi\n"); }
> about to run
> hi
> done running, took 28295 usecs

I like the example, but it sidesteps the main problem, which is
putting the expression in the context from which it was called.
For instance if I stop in the middle of a function and type

  print foo->bar( a + b )

I need to find the find the variable names, lookup their types,
do overload resolution, possibly do template instantiation, etc,
all as if the compiler was in the scope defined for the line that
the debugger is stopped at.  That's the hard part.

> Maybe your thinking of lisp, certainly that language makes
> it hard.  ;-P

Actually, a read-eval-print loop in Lisp is easy.

-- 
Lawrence Crowl

Sign in to reply to this message.

Lawrence Crowl

On 5/18/12, Diego Novillo <dnovillo@google.com> wrote: > So, I would like to figure out what ...

11 years, 11 months ago (2012-05-19 02:54:12 UTC) #31

rth_redhat.com

On 05/18/2012 04:48 PM, Diego Novillo wrote: > We can do this in trunk today ...

11 years, 11 months ago (2012-05-20 17:59:26 UTC) #32

Diego Novillo

On 12-05-20 13:59 , Richard Henderson wrote: > On 05/18/2012 04:48 PM, Diego Novillo wrote: ...

11 years, 11 months ago (2012-05-20 19:10:51 UTC) #33

richard.guenther_gmail.com

On Sun, May 20, 2012 at 9:10 PM, Diego Novillo <dnovillo@google.com> wrote: > On 12-05-20 ...

11 years, 11 months ago (2012-05-21 10:18:14 UTC) #34

richard.guenther_gmail.com

On Mon, May 21, 2012 at 12:18 PM, Richard Guenther <richard.guenther@gmail.com> wrote: > On Sun, ...

11 years, 11 months ago (2012-05-21 11:53:11 UTC) #35

amonakov_ispras.ru

On Thu, 17 May 2012, Tom Tromey wrote: > It would be nice if there ...

11 years, 11 months ago (2012-05-21 15:44:36 UTC) #36

mikestump_comcast.net

On May 18, 2012, at 7:48 PM, Lawrence Crowl wrote: > On 5/17/12, Mike Stump ...

11 years, 11 months ago (2012-05-21 20:51:14 UTC) #37

On May 18, 2012, at 7:48 PM, Lawrence Crowl wrote:
> On 5/17/12, Mike Stump <mikestump@comcast.net> wrote:
>> On May 17, 2012, at 2:41 PM, Lawrence Crowl wrote:
>>>> Reusing the compiler for this seems like the only way to go.
>>>> But, we did look at using g++ to parse C++ expressions from gdb,
>>>> and it was too slow :-(.  We're going to look again, at least to
>>>> generate some bug reports if we can.
>>> 
>>> It's a tough problem, particularly as C/C++ and their compilers
>>> were not designed for a read-eval-print-loop environment.
>> 
>> This of course is trivial to do,
> 
> I do not think that word means what you think it means.  :-)

Excellent reference...  Yeah, well, just a little more work to do:

$ ./eval
extern "C" int printf(const char *...); int &k2 = *(int*)4294971592; void
eval()\
 { printf("k is %d\n", k2); }
about to run
k is 42
done running, took 32540 usecs

Notice, this sucked a int k2 = 42; that was a variable inside the context in
which I wanted a k2.  The nature of the variable is irrelevant, could be a stack
variable, could be a global, a static top-level, all I need to know, is where it
is (the address) and the type and I generate a binding stub for it into the
context, and presto, complete access to most all variables.  This does make use
of C++ to manage the variables in a slightly nicer way.  One either has to
inject all variables and functions into the context into which the program
fragment is compiled, or notice which variables and function are or might be
used and inject just those.

I've seen ptype foo print the types of variables, so, it isn't far off, and
certainly gdb knows about the symbol table and can figure out the addresses of
those variables, right?!

Now, certainly one can find additional issues, and yes, there is a bit of work
to get 100% reliability that we'd like from the scheme.  For example, packed
structures would need work, as ptype isn't going to get that right from that
start.  I think the functionality one would get would be good enough to start
with, and in time, better support for things ptype doesn't get right would fix a
certain class of problems.

So, what another 1000 lines to generate the context for the fragment... I guess
finding references could be annoying, and the time required to generate and
compile the entire context could be annoying...

Doing C++ would be harder, though, not quite for the reason you gave.

> I like the example, but it sidesteps the main problem, which is
> putting the expression in the context from which it was called.
> For instance if I stop in the middle of a function and type
> 
>  print foo->bar( a + b )
> 
> I need to find the find the variable names, lookup their types,

ptype a does the lookup for a, and finds the type, so that isn't hard, same with
b and foo.  Harder would be to synthesize the context for the fragment to live
in.  To do this and work with templates, you'd need the entire template bodies
to be in the debug information and to output them when generating the context
that might use them.

class A {
  foo() { }
}

when stopped in foo, one needs to generate:

class A {
  foo();
  __eval() { fragment }
}

and then call __eval(lookup("this"))...  The compiler does the overload
resolution, the template instantiation and so on.  To ensure the compiler does
name loookup right, one just needs to generate the context for that fragment
carefully.

> do overload resolution, possibly do template instantiation, etc,
> all as if the compiler was in the scope defined for the line that
> the debugger is stopped at.  That's the hard part.

Sign in to reply to this message.

tromey_redhat.com

>>>>> "Alexander" == Alexander Monakov <amonakov@ispras.ru> writes: Alexander> Hm, isn't GDB's 'set unwindonsignal on' enough ...

11 years, 11 months ago (2012-05-21 20:54:57 UTC) #38

Lawrence Crowl

On 5/21/12, Mike Stump <mikestump@comcast.net> wrote: > On May 18, 2012, at 7:48 PM, Lawrence ...

11 years, 11 months ago (2012-05-23 22:36:02 UTC) #39

On 5/21/12, Mike Stump <mikestump@comcast.net> wrote:
> On May 18, 2012, at 7:48 PM, Lawrence Crowl wrote:
>> On 5/17/12, Mike Stump <mikestump@comcast.net> wrote:
>>> On May 17, 2012, at 2:41 PM, Lawrence Crowl wrote:
>>>>> Reusing the compiler for this seems like the only way to go.
>>>>> But, we did look at using g++ to parse C++ expressions from gdb,
>>>>> and it was too slow :-(.  We're going to look again, at least to
>>>>> generate some bug reports if we can.
>>>>
>>>> It's a tough problem, particularly as C/C++ and their compilers
>>>> were not designed for a read-eval-print-loop environment.
>>>
>>> This of course is trivial to do,
>>
>> I do not think that word means what you think it means.  :-)
>
> Excellent reference...  Yeah, well, just a little more work to do:
>
> $ ./eval
> extern "C" int printf(const char *...); int &k2 = *(int*)4294971592;
> void eval() { printf("k is %d\n", k2); }
> about to run
> k is 42
> done running, took 32540 usecs
>
> Notice, this sucked a int k2 = 42; that was a variable inside
> the context in which I wanted a k2.  The nature of the variable
> is irrelevant, could be a stack variable, could be a global,
> a static top-level, all I need to know, is where it is (the
> address) and the type and I generate a binding stub for it into
> the context, and presto, complete access to most all variables.
> This does make use of C++ to manage the variables in a slightly
> nicer way.  One either has to inject all variables and functions
> into the context into which the program fragment is compiled,
> or notice which variables and function are or might be used and
> inject just those.
>
> I've seen ptype foo print the types of variables, so, it isn't
> far off, and certainly gdb knows about the symbol table and can
> figure out the addresses of those variables, right?!

For variables that are not optimized out of memory, I think this
can work.  But if you need to go for registers, or undo a variable
elimination, the effort gets harder.

>
> Now, certainly one can find additional issues, and yes, there
> is a bit of work to get 100% reliability that we'd like from
> the scheme.  For example, packed structures would need work, as
> ptype isn't going to get that right from that start.  I think the
> functionality one would get would be good enough to start with,
> and in time, better support for things ptype doesn't get right
> would fix a certain class of problems.

Agreed.

>
> So, what another 1000 lines to generate the context for the
> fragment... I guess finding references could be annoying, and the
> time required to generate and compile the entire context could
> be annoying...
>
> Doing C++ would be harder, though, not quite for the reason
> you gave.
>
>> I like the example, but it sidesteps the main problem, which is
>> putting the expression in the context from which it was called.
>> For instance if I stop in the middle of a function and type
>>
>>  print foo->bar( a + b )
>>
>> I need to find the find the variable names, lookup their types,
>
> ptype a does the lookup for a, and finds the type, so that isn't
> hard, same with b and foo.  Harder would be to synthesize the
> context for the fragment to live in.  To do this and work with
> templates, you'd need the entire template bodies to be in the
> debug information and to output them when generating the context
> that might use them.

Yes, you essentially need to come close to sending the compiler's
symbol tables through the debug information.  I don't know of any
compiler/debugger pair that is close to that capability.  That said,
I don't know all such pairs either.

>
> class A {
>   foo() { }
> }
>
> when stopped in foo, one needs to generate:
>
> class A {
>   foo();
>   __eval() { fragment }
> }
>
> and then call __eval(lookup("this"))...  The compiler does
> the overload resolution, the template instantiation and so on.
> To ensure the compiler does name loookup right, one just needs
> to generate the context for that fragment carefully.

Agreed.

>> do overload resolution, possibly do template instantiation, etc,
>> all as if the compiler was in the scope defined for the line that
>> the debugger is stopped at.  That's the hard part.

I'm not saying that the task is impossible, only that there is a
lot of work to do before we get there.

-- 
Lawrence Crowl

Sign in to reply to this message.

Lawrence Crowl

On 5/21/12, Tom Tromey <tromey@redhat.com> wrote: >>>>>> "Alexander" == Alexander Monakov <amonakov@ispras.ru> writes: > > ...

11 years, 11 months ago (2012-05-23 22:36:40 UTC) #40

mikestump_comcast.net

On May 23, 2012, at 3:36 PM, Lawrence Crowl wrote: > For variables that are ...

11 years, 11 months ago (2012-05-24 00:24:43 UTC) #41

On May 23, 2012, at 3:36 PM, Lawrence Crowl wrote:
> For variables that are not optimized out of memory, I think this
> can work.  But if you need to go for registers,

Also trivial...  Just one has to generate the context correctly.  One has to
save off the registers and then in the context generator, synthesize them back
up.  So, take a context in which a is in register 5, one can generate something
like:

void eval() {
    register int a = __gdb_registers[5];

    <snippet>

   __gdb_registers[5] = a;
  }

This preserves the value in register 5 from the gdb context at that point, and
even allows the user to write to such variables, and have that reflected in the
register file.

> or undo a variable elimination, the effort gets harder.

Yes, setting the value of a variable that has, for example, been removed due to
dce, is annoying.  But I'll note it is annoying in gdb currently.  I'd be happy
to introduce declarations that if used, lead to compile time errors.  Darwin for
example has an unavailable attribute one can attach to a decl to ensure an error
is produced.  gcc has deprecated, though, it is just a warning.

Now, for variables that can be computed from variables that are present, I'd
rather the optimizer explain how to produce the value given the state and for
gdb to producea context with that value into a read only variable.  This
preserves for read access such variables that are gone.  This is something that
gcc and gdb should be doing anyway...  but don't.

> Yes, you essentially need to come close to sending the compiler's
> symbol tables through the debug information.  I don't know of any
> compiler/debugger pair that is close to that capability.

:-)  Not yet...  Maybe never.

> I'm not saying that the task is impossible, only that there is a
> lot of work to do before we get there.

Yeah, I kinda think the gdb people are wimping out by not just implementing
__extension__ and ({}), which, I think get us most of the way there.  Shh, don't
tell them I said that.

Sign in to reply to this message.

tromey_redhat.com

>>>>> "Lawrence" == Lawrence Crowl <crowl@google.com> writes: Lawrence> Should I add that to my patch ...

11 years, 11 months ago (2012-05-25 18:14:30 UTC) #42

tromey_redhat.com

11 years, 11 months ago (2012-05-25 18:14:56 UTC) #43

>>>>> "Mike" == Mike Stump <mikestump@comcast.net> writes:

Mike> Yeah, I kinda think the gdb people are wimping out by not just
Mike> implementing __extension__ and ({}), which, I think get us most of the
Mike> way there.  Shh, don't tell them I said that.

We eagerly await your patch.

Tom

Sign in to reply to this message.

Issue 6188088: Turn check macros into functions. (Closed)

Patch Set 1 #

Messages