[Bug jit/122443] Huge memory usage in walk_tree_1 with deeply nested expressions

[pinskia at gcc dot gnu.org via Gcc-bugs]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=122443

--- Comment #4 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
I should note fold is not recusive.


```
  tree inner_expr = build2 (inner_op,
                            result_type->as_tree (),
                            node_a,
                            node_b);

  /* Try to fold the expression.  */
  inner_expr = fold (inner_expr);
```

Really uses way too much memory if fold does something too.

Just use fold_build2 here.

Likewise here too:
```
  if (VECTOR_TYPE_P (a_type))
  {
    /* Build a vector comparison.  See build_vec_cmp in c-typeck.cc for
       reference.  */
    tree t_vec_result_type = vec_result_type->as_tree ();
    tree zero_vec = build_zero_cst (t_vec_result_type);
    tree minus_one_vec = build_minus_one_cst (t_vec_result_type);
    tree cmp_type = truth_type_for (a_type);
    tree cmp = build2 (inner_op, cmp_type, node_a, node_b);
    inner_expr = build3 (VEC_COND_EXPR, t_vec_result_type, cmp, minus_one_vec,
                         zero_vec);
  }
  else
  {
    inner_expr = build2 (inner_op,
                         boolean_type_node,
                         node_a,
                         node_b);
  }

  /* Try to fold.  */
  inner_expr = fold (inner_expr);

```