This is the mail archive of the gcc@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [GSoC] writing test-case


On Wed, May 14, 2014 at 4:40 PM, Richard Biener
<richard.guenther@gmail.com> wrote:
> On Tue, May 13, 2014 at 11:06 PM, Prathamesh Kulkarni
> <bilbotheelffriend@gmail.com> wrote:
>> On Tue, May 13, 2014 at 2:36 PM, Richard Biener
>> <richard.guenther@gmail.com> wrote:
>>> On Sun, May 11, 2014 at 5:00 PM, Prathamesh Kulkarni
>>> <bilbotheelffriend@gmail.com> wrote:
>>>> On Sun, May 11, 2014 at 8:10 PM, Andreas Schwab <schwab@linux-m68k.org> wrote:
>>>>> Prathamesh Kulkarni <bilbotheelffriend@gmail.com> writes:
>>>>>
>>>>>> a) I am not able to follow why 3 slashes are required here
>>>>>> in x_.\\\(D\\\) ? Why does x_.\(D\) not work ?
>>>>>
>>>>> Two of the three backslashes are eaten by the tcl parser.  But actually
>>>>> only two backslashes are needed, since the parens are not special to tcl
>>>>> (but are special to the regexp engine, so you want a single backslash
>>>>> surviving the tcl parser).
>>>>>
>>>>>> b) The expression after folding would be of the form:
>>>>>> t2_<digit> = x_<digit>(D) - y_<digit>(D)
>>>>>> I have used the operator "." in the pattern to match digit.
>>>>>> While that works in the above case, I think a better
>>>>>> idea would be to match using [0-9].
>>>>>> I tried the following but it does not work:
>>>>>> t_[0-9] = x_[0-9]\\\(D\\\) - y_[0-9]\\\(D\\\)
>>>>>> Neither does \\\[ and \\\] work.
>>>>>
>>>>> Brackets are special in tcl (including inside double quotes), so they
>>>>> need to be quoted.  But you want the brackets to appear unquoted to the
>>>>> regexp engine, so a single backslash will do the Right Thing.
>>>>>
>>>>> See tcl(n) for the tcl parsing rules.
>>>>>
>>>> Thanks. Now I get it, the double backslash \\ is an escape sequence
>>>> for \, and special characters like (, [
>>>> retain their meaning in quotes, so to match input text: (D), the
>>>> pattern has to be written as: "\\(D\\)".
>>>> I believe "\(D\)" would only match D in the input ?
>>>> I have modified the test-case. Is this version correct ?
>>>
>>> I usually verify that by running the testcase in isolation on a GCC version
>>> that should FAIL it and on one that should PASS it (tcl quoting is also
>>> try-and-error for me most of the time...).
>>>
>>> Thus I do
>>>
>>> gcc/> make check-gcc RUNTESTFLAGS="tree-ssa.exp=match-2.c"
>>> <test should FAIL>
>>> <patch source tree>
>>> gcc/> make cc1
>>> ... compiles cc1 ...
>>> gcc/> make check-gcc RUNTESTFLAGS="tree-ssa.exp=match-2.c"
>>> <test should PASS>
>>>
>>> A more complete matching for an SSA name would be (allowing
>>> for SSA name versions > 9) _\\d\+ with \\(D\\) appended if
>>> suitable (that's usually known from the testcase).  \\d\+ should match
>>> at least one decimal digit.
>> I thought that SSA name version wouldn't exceed 9 for that test-case,
>> so I decided for matching only one digit. I will change it to match
>> one or more digits.
>>
>> * I have written test-cases for patterns in match.pd (attached patch), which
>> result in PASS. Could you review them for me ?
>
> Sure.  It looks good to me, though you can look at the changed match-1.c
> testcase on the branch where I've changed the matching to look for the
> debug output the forwprop pass dumps with -fdump-tree-forwprop1-details,
> that makes sure no other pass before did the transform (you can also
> move the individual dg-final lines after the testcase function to more
> easily associate them with a function).
Thanks, modified the patch to scan for "gimple_match_and_simplified" instead.
>
> At some point the testcase should be split up as well.
>
> How do you manage your sources at the moment?  Just a svn
> checkout of the branch with local modifications?
Yes.
>
> Thanks,
> Richard.
Index: gcc/match.pd
===================================================================
--- gcc/match.pd	(revision 210434)
+++ gcc/match.pd	(working copy)
@@ -21,7 +21,6 @@ You should have received a copy of the G
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
-
 /* Transforms formerly done by tree-ssa-forwprop.c:associate_plusminus  */
 
 /* ???  Have match_and_simplify groups guarded with common
@@ -98,6 +97,32 @@ to (minus @1 @0)
    (T)(P + A) - (T)P  -> (T)A
  */
 
+/* ~A + A -> -1 */
+(match_and_simplify
+  (plus (bit_not @0) @0)
+  if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))
+  { build_int_cst (TREE_TYPE (@0), -1); })
+
+/* ~A + 1 -> -A */
+(match_and_simplify
+  (plus (bit_not @0) integer_onep)
+  if (INTEGRAL_TYPE_P (TREE_TYPE (@0)))
+  (negate @0)) 
+
+/* A - (A +- B) -> -+ B */
+(match_and_simplify
+  (minus @0 (plus @0 @1))
+  (negate @0))
+
+(match_and_simplify
+  (minus @0 (minus @0 @1))
+  @1)
+
+/* (T)(P + A) - (T)P -> (T) A */
+(match_and_simplify
+  (minus (convert (pointer_plus @0 @1))
+	 (convert @0))
+  (convert @1)) 
 
 /* Patterns required to avoid SCCVN testsuite regressions.  */
 
Index: gcc/testsuite/gcc.dg/tree-ssa/match-2.c
===================================================================
--- gcc/testsuite/gcc.dg/tree-ssa/match-2.c	(revision 0)
+++ gcc/testsuite/gcc.dg/tree-ssa/match-2.c	(working copy)
@@ -0,0 +1,118 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fdump-tree-forwprop-details" }  */
+
+/* x + (-y) -> x - y */
+int f1(int x, int y)
+{
+  int t1 = -y;
+  return x + t1; 
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\) - y_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* x - (-y) -> y + x */
+int f2(int x, int y)
+{
+  int t1 = -y;
+  return x - t1; 
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= y_\\d\+\\(D\\) \\+ x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* (x + y) - x -> y */
+int f3(int x, int y)
+{
+  int t1 = x + y;
+  return t1 - x;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= y_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* (x - y) - x -> -y */
+int f4(int x, int y)
+{
+  int t1 = x - y;
+  return t1 - x;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= -y_\\d\+\\(D\\)" "forwprop1" } } */ 
+
+/* (x + y) - y -> x */
+int f5(int x, int y)
+{
+  int t1 = x + y;
+  return t1 - y;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* (x - y) + y -> x */
+int f6(int x, int y)
+{
+  int t1 = x - y;
+  return t1 + y;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* (x + cst1) + cst2 -> x + (cst1 + cst2) */
+int f7(int x)
+{
+  int t1 = x + 3;
+  return t1 + 4;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\) \\+ 7" "forwprop1" } } */ 
+
+/* (cst1 - x) + cst2 -> (cst1 + cst2) - x */
+int f8(int x)
+{
+  int t1 = 3 - x;
+  return t1 + 4;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= 7 - x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* (x >> 31) & 1 -> x >> 31 */
+int f9(int x)
+{
+  int t1 = x >> 31;
+  return t1 & 1;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= t1_\\d\+" "forwprop1" } } */
+
+/* -(~x) -> x + 1 */
+int f10(int x)
+{
+  int t1, t2;
+  t1 = ~x;
+  t2 = -t1;
+  return t2;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\) \\+ 1" "forwprop1" } } */
+
+/* x + ~x -> -1 */
+int f11(int x)
+{
+  int t1 = ~x;
+  return t1 + x;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= -1" "forwprop1" } } */
+
+/* ~x + 1 -> -x */
+int f12(int x)
+{
+  int t1 = ~x;
+  return t1 + 1;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= -x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* __real complex (__real x) = x */
+double f13(double x)
+{
+  _Complex double t1 = x;
+  return __real t1;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* __imag complex (__imag x) = x */
+double f14(double x)
+{
+  _Complex double t1 = x;
+  return __imag t1;
+}
+/* { dg-final { scan-tree-dump "gimple_match_and_simplified to \[^\n\r\]*= x_\\d\+\\(D\\)" "forwprop1" } } */
+
+/* { dg-final { cleanup-tree-dump "forwprop2" } } */

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]