From patchwork Mon May 30 13:27:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aldy Hernandez X-Patchwork-Id: 54527 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id DEDF03857343 for ; Mon, 30 May 2022 13:28:36 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org DEDF03857343 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1653917316; bh=/EeOqfZArpSfe53tJs+juGzKEGEyDgV+OC2VJy4qSCc=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=ZhBJ8tIYF5IkF0gZJdFrszo7cEhoOAU1ZSXJQ4Mu6p7snRP/OoAsmjQ6xopQwNiqH 10dxD5VyueYGcPgdf54tis3FUG8ndM8a+u3bLLVukLGoSbaBvRMXgz4Vj0rp3b9L0f wa/7rM6gYtC4lVn20LLwJXLAia5UPtBvOCD2OK9I= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id A5810385800E for ; Mon, 30 May 2022 13:28:05 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org A5810385800E Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-607-0vkv8KQZPROKt_PJ3cwFSQ-1; Mon, 30 May 2022 09:28:03 -0400 X-MC-Unique: 0vkv8KQZPROKt_PJ3cwFSQ-1 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.rdu2.redhat.com [10.11.54.4]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id A91D6185A79C for ; Mon, 30 May 2022 13:28:03 +0000 (UTC) Received: from abulafia.quesejoda.com (unknown [10.39.194.246]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 358BD2026D07; Mon, 30 May 2022 13:28:03 +0000 (UTC) Received: from abulafia.quesejoda.com (localhost [127.0.0.1]) by abulafia.quesejoda.com (8.17.1/8.17.1) with ESMTPS id 24UDS0Nt1752170 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Mon, 30 May 2022 15:28:00 +0200 Received: (from aldyh@localhost) by abulafia.quesejoda.com (8.17.1/8.17.1/Submit) id 24UDS01Y1752164; Mon, 30 May 2022 15:28:00 +0200 To: GCC patches Subject: [PATCH 1/5] Implement abstract vrange class. Date: Mon, 30 May 2022 15:27:47 +0200 Message-Id: <20220530132751.1752112-1-aldyh@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.78 on 10.11.54.4 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.5 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Aldy Hernandez via Gcc-patches From: Aldy Hernandez Reply-To: Aldy Hernandez Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" This is a series of patches making ranger type agnostic in preparation for contributing support for other types of ranges (pointers and floats initially). The first step in this process is to implement vrange, an abstract class that will be exclusively used by ranger, and from which all ranges will inherit. Vrange provides the minimum operations for ranger to work. The current virtual methods are what we've used to implement frange (floats) and prange (pointers), but we may restrict the virtual methods further as other ranges come about (i.e. set_nonnegative() has no meaning for a future string range). This patchset also provides a mechanism for declaring local type agnostic ranges that can transparently hold an irange, frange, prange's, etc, and a dispatch mechanism for range-ops to work with various range types. More details in the relevant patches. FUTURE PLAN =========== The plan after this is to contribute a bare bones implementation for floats (frange) that will provide relationals, followed by a separation of integers and pointers (irange and prange). Once this is in place, we can further enhance both floats and pointers. For example, pointer tracking, pointer plus optimizations, and keeping track of NaN's, etc. Once frange and prange come live, all ranger clients will immediately benefit from these enhancements. For instance, in our local branch, the threader is already float aware with regards to relationals. We expect to wait a few weeks before starting to contribute further enhancements to give the tree a time to stabilize, and Andrew time to rebase his upcoming patches :-P. NOTES ===== In discussions with Andrew, it has become clear that with vrange coming about, supports_type_p() is somewhat ambiguous. Prior to vrange it has been used to (a) determine if a type is supported by ranger, (b) as a short-cut for checking if a type is pointer or integer, as well as (c) to see if a given range can hold a type. These things have had the same meaning in irange, but are slightly different with vrange. I will address this in a follow-up patch. Speaking of supported types, we now provide an unsupported_range for passing around ranges for unsupported types. We've been silently doing this for a while, in both vr-values by creating VARYING for unsupported types with error_mark_node end points, and in ranger when we pass an unsupported range before we realize in range_of_expr that it's unsupported. This class just formalizes what we've already been doing in an irange, but making it explicit that you can't do anything with these ranges except pass them. Any other operation traps. There is no GTY support for vrange yet, as we don't store it long term. When we contribute support for global ranges (think SSA_NAME_RANGE_INFO but for generic ranges), we will include it. There was just no need to pollute this patchset with it. TESTING ======= The patchset has been tested on x86-64 Linux as well as ppc64 Linux. I have also verified that we fold the same number of conditionals in evrp as well as thread the same number of paths. There should be no user visible changes. We have also benchmarked the work, with the final numbers being an *improvement* of 1.92% for evrp, and 0.82% for VRP. Overall compilation has a miniscule improvement. This is despite the extra indirection level. The improvements are mostly because of small cleanups required for the generalization of ranges. As a sanity check, I stuck kcachegrind on a few sample .ii files to see where the time was being gained. Most of the gain came from gimple_range_global() being 19% faster. This function is called a lot, and it was constructing a legacy value_range, then returning it by value, which the caller then had to convert to an irange. This is in line with other pending work: anytime we get rid of legacy, we gain time. I will wait a few days before committing to welcome any comments. gcc/ChangeLog: * value-range-equiv.cc (value_range_equiv::set): New. * value-range-equiv.h (class value_range_equiv): Make set method virtual. Remove default bitmap argument from set method. * value-range.cc (vrange::contains_p): New. (vrange::singleton_p): New. (vrange::operator=): New. (vrange::operator==): New. (irange::fits_p): Move to .cc file. (irange::set_nonnegative): New. (unsupported_range::unsupported_range): New. (unsupported_range::set): New. (unsupported_range::type): New. (unsupported_range::set_undefined): New. (unsupported_range::set_varying): New. (unsupported_range::dump): New. (unsupported_range::union_): New. (unsupported_range::intersect): New. (unsupported_range::zero_p): New. (unsupported_range::nonzero_p): New. (unsupported_range::set_nonzero): New. (unsupported_range::set_zero): New. (unsupported_range::set_nonnegative): New. (unsupported_range::fits_p): New. (irange::set): Call irange::set_undefined. (irange::verify_range): Check discriminator field. (irange::dump): Dump [irange] marker. (irange::debug): Move to... (vrange::debug): ...here. (dump_value_range): Accept vrange. (debug): Same. * value-range.h (enum value_range_discriminator): New. (class vrange): New. (class unsupported_range): New. (struct vrange_traits): New. (is_a): New. (as_a): New. (class irange): Inherit from vrange. (dump_value_range): Adjust for vrange. (irange::kind): Rename to... (vrange::kind): ...this. (irange::varying_p): Rename to... (vrange::varying_p): ...this. (irange::undefined_p): Rename to... (vrange::undefined_p): ...this. (irange::irange): Set discriminator. (irange::union_): Convert to irange before passing to irange method. (irange::intersect): Same. (vrange::supports_type_p): New. * vr-values.cc (vr_values::extract_range_from_binary_expr): Pass NULL bitmap argument to value_range_equiv::set. (vr_values::extract_range_basic): Same. --- gcc/value-range-equiv.cc | 6 ++ gcc/value-range-equiv.h | 3 +- gcc/value-range.cc | 168 ++++++++++++++++++++++++++++++++- gcc/value-range.h | 195 ++++++++++++++++++++++++++++++++------- gcc/vr-values.cc | 6 +- 5 files changed, 338 insertions(+), 40 deletions(-) diff --git a/gcc/value-range-equiv.cc b/gcc/value-range-equiv.cc index 77c6f5ca99d..b0ae1288a09 100644 --- a/gcc/value-range-equiv.cc +++ b/gcc/value-range-equiv.cc @@ -50,6 +50,12 @@ value_range_equiv::set (tree min, tree max, bitmap equiv, check (); } +void +value_range_equiv::set (tree min, tree max, value_range_kind kind) +{ + set (min, max, m_equiv, kind); +} + void value_range_equiv::set (tree val) { diff --git a/gcc/value-range-equiv.h b/gcc/value-range-equiv.h index 0aa1069cb61..743ceb2b227 100644 --- a/gcc/value-range-equiv.h +++ b/gcc/value-range-equiv.h @@ -41,9 +41,10 @@ class GTY((user)) value_range_equiv : public value_range void move (value_range_equiv *); /* Leaves equiv bitmap alone. */ + virtual void set (tree, tree, value_range_kind = VR_RANGE) override; void update (tree, tree, value_range_kind = VR_RANGE); /* Deep-copies equiv bitmap argument. */ - void set (tree, tree, bitmap = NULL, value_range_kind = VR_RANGE); + void set (tree, tree, bitmap, value_range_kind = VR_RANGE); void set (tree); bool operator== (const value_range_equiv &) const /* = delete */; diff --git a/gcc/value-range.cc b/gcc/value-range.cc index 2e7385aecc2..97ff0614f48 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -30,6 +30,162 @@ along with GCC; see the file COPYING3. If not see #include "fold-const.h" #include "gimple-range.h" +// Default implementation when none has been defined. + +bool +vrange::contains_p (tree) const +{ + return false; +} + +// Default implementation when none has been defined. + +bool +vrange::singleton_p (tree *) const +{ + return false; +} + +// Assignment operator for generic ranges. Copying incompatible types +// is not allowed. + +vrange & +vrange::operator= (const vrange &src) +{ + if (is_a (src)) + { + as_a (*this) = as_a (src); + return *this; + } + else + gcc_unreachable (); +} + +// Equality operator for generic ranges. + +bool +vrange::operator== (const vrange &src) const +{ + if (is_a (src)) + return as_a (*this) == as_a (src); + gcc_unreachable (); +} + +// Return TRUE if R fits in THIS. + +bool +irange::fits_p (const vrange &r) const +{ + return m_max_ranges >= as_a (r).num_pairs (); +} + +void +irange::set_nonnegative (tree type) +{ + set (build_int_cst (type, 0), TYPE_MAX_VALUE (type)); +} + +unsupported_range::unsupported_range () +{ + m_discriminator = VR_UNKNOWN; + set_undefined (); +} + +void +unsupported_range::set (tree, tree, value_range_kind) +{ + gcc_unreachable (); +} + +tree +unsupported_range::type () const +{ + gcc_unreachable (); + return nullptr; +} + +void +unsupported_range::set_undefined () +{ + m_kind = VR_UNDEFINED; +} + +void +unsupported_range::set_varying (tree) +{ + gcc_unreachable (); +} + +void +unsupported_range::dump (FILE *file) const +{ + fprintf (file, "[unsupported_range] "); + if (undefined_p ()) + { + fprintf (file, "UNDEFINED"); + return; + } + if (varying_p ()) + { + fprintf (file, "VARYING"); + return; + } + gcc_unreachable (); +} + +bool +unsupported_range::union_ (const vrange &) +{ + gcc_unreachable (); + return false; +} + +bool +unsupported_range::intersect (const vrange &) +{ + gcc_unreachable (); + return false; +} + +bool +unsupported_range::zero_p () const +{ + gcc_unreachable (); + return false; +} + +bool +unsupported_range::nonzero_p () const +{ + gcc_unreachable (); + return false; +} + +void +unsupported_range::set_nonzero (tree) +{ + gcc_unreachable (); +} + +void +unsupported_range::set_zero (tree) +{ + gcc_unreachable (); +} + +void +unsupported_range::set_nonnegative (tree) +{ + gcc_unreachable (); +} + +bool +unsupported_range::fits_p (const vrange &) const +{ + gcc_unreachable (); + return false; +} + // Here we copy between any two irange's. The ranges can be legacy or // multi-ranges, and copying between any combination works correctly. @@ -291,7 +447,7 @@ irange::set (tree min, tree max, value_range_kind kind) } if (kind == VR_UNDEFINED) { - set_undefined (); + irange::set_undefined (); return; } @@ -370,6 +526,7 @@ irange::set (tree min, tree max, value_range_kind kind) void irange::verify_range () { + gcc_checking_assert (m_discriminator == VR_IRANGE); if (m_kind == VR_UNDEFINED) { gcc_checking_assert (m_num_ranges == 0); @@ -2087,6 +2244,7 @@ dump_bound_with_infinite_markers (FILE *file, tree bound) void irange::dump (FILE *file) const { + fprintf (file, "[irange] "); if (undefined_p ()) { fprintf (file, "UNDEFINED"); @@ -2121,27 +2279,27 @@ irange::dump (FILE *file) const } void -irange::debug () const +vrange::debug () const { dump (stderr); fprintf (stderr, "\n"); } void -dump_value_range (FILE *file, const irange *vr) +dump_value_range (FILE *file, const vrange *vr) { vr->dump (file); } DEBUG_FUNCTION void -debug (const irange *vr) +debug (const vrange *vr) { dump_value_range (stderr, vr); fprintf (stderr, "\n"); } DEBUG_FUNCTION void -debug (const irange &vr) +debug (const vrange &vr) { debug (&vr); } diff --git a/gcc/value-range.h b/gcc/value-range.h index ec59d2e4f23..0061f667092 100644 --- a/gcc/value-range.h +++ b/gcc/value-range.h @@ -22,6 +22,8 @@ along with GCC; see the file COPYING3. If not see #ifndef GCC_VALUE_RANGE_H #define GCC_VALUE_RANGE_H +class irange; + // Types of value ranges. enum value_range_kind { @@ -37,24 +39,71 @@ enum value_range_kind VR_LAST }; -// Range of values that can be associated with an SSA_NAME. -// -// This is the base class without any storage. +// Discriminator between different vrange types. + +enum value_range_discriminator +{ + // Range holds an integer or pointer. + VR_IRANGE, + // Range holds an unsupported type. + VR_UNKNOWN +}; + +// Abstract class for ranges of any of the supported types. + +class vrange +{ + template friend bool is_a (vrange &); +public: + virtual void set (tree, tree, value_range_kind = VR_RANGE) = 0; + virtual tree type () const = 0; + virtual void set_varying (tree type) = 0; + virtual void set_undefined () = 0; + virtual void dump (FILE * = stderr) const = 0; + virtual bool union_ (const vrange &) = 0; + virtual bool intersect (const vrange &) = 0; + virtual bool singleton_p (tree *result = NULL) const; + virtual bool contains_p (tree cst) const; + virtual bool zero_p () const = 0; + virtual bool nonzero_p () const = 0; + virtual void set_nonzero (tree type) = 0; + virtual void set_zero (tree type) = 0; + virtual void set_nonnegative (tree type) = 0; + virtual bool fits_p (const vrange &r) const = 0; + + static bool supports_type_p (tree); + + bool varying_p () const; + bool undefined_p () const; + vrange& operator= (const vrange &); + bool operator== (const vrange &) const; + bool operator!= (const vrange &r) const { return !(*this == r); } + + enum value_range_kind kind () const; // DEPRECATED + void debug () const; + +protected: + ENUM_BITFIELD(value_range_kind) m_kind : 8; + ENUM_BITFIELD(value_range_discriminator) m_discriminator : 4; +}; + +// An integer range without any storage. -class GTY((user)) irange +class GTY((user)) irange : public vrange { friend class irange_allocator; public: // In-place setters. - void set (tree, tree, value_range_kind = VR_RANGE); - void set_nonzero (tree); - void set_zero (tree); - void set_varying (tree type); - void set_undefined (); + virtual void set (tree, tree, value_range_kind = VR_RANGE) override; + virtual void set_nonzero (tree type) override; + virtual void set_zero (tree type) override; + virtual void set_nonnegative (tree type) override; + virtual void set_varying (tree type) override; + virtual void set_undefined () override; // Range types. static bool supports_type_p (tree); - tree type () const; + virtual tree type () const override; // Iteration over sub-ranges. unsigned num_pairs () const; @@ -63,16 +112,14 @@ public: wide_int upper_bound () const; // Predicates. - bool zero_p () const; - bool nonzero_p () const; - bool undefined_p () const; - bool varying_p () const; - bool singleton_p (tree *result = NULL) const; - bool contains_p (tree) const; + virtual bool zero_p () const override; + virtual bool nonzero_p () const override; + virtual bool singleton_p (tree *result = NULL) const override; + virtual bool contains_p (tree cst) const override; // In-place operators. - bool union_ (const irange &); - bool intersect (const irange &); + virtual bool union_ (const vrange &) override; + virtual bool intersect (const vrange &) override; void invert (); // Operator overloads. @@ -81,12 +128,10 @@ public: bool operator!= (const irange &r) const { return !(*this == r); } // Misc methods. - bool fits_p (const irange &r) { return m_max_ranges >= r.num_pairs (); } - void dump (FILE * = stderr) const; - void debug () const; + virtual bool fits_p (const vrange &r) const override; + virtual void dump (FILE * = stderr) const override; // Deprecated legacy public methods. - enum value_range_kind kind () const; // DEPRECATED tree min () const; // DEPRECATED tree max () const; // DEPRECATED bool symbolic_p () const; // DEPRECATED @@ -139,7 +184,6 @@ private: bool intersect (const wide_int& lb, const wide_int& ub); unsigned char m_num_ranges; unsigned char m_max_ranges; - ENUM_BITFIELD(value_range_kind) m_kind : 8; tree *m_base; }; @@ -173,6 +217,88 @@ private: tree m_ranges[N*2]; }; +// Unsupported temporaries may be created by ranger before it's known +// they're unsupported, or by vr_values::get_value_range. All +// operations except construction cause a trap. + +class unsupported_range : public vrange +{ +public: + unsupported_range (); + virtual void set (tree, tree, value_range_kind) override; + virtual tree type () const override; + virtual void set_varying (tree type) override; + virtual void set_undefined () override; + virtual void dump (FILE *) const override; + virtual bool union_ (const vrange &) override; + virtual bool intersect (const vrange &) override; + virtual bool zero_p () const override; + virtual bool nonzero_p () const override; + virtual void set_nonzero (tree) override; + virtual void set_zero (tree) override; + virtual void set_nonnegative (tree) override; + virtual bool fits_p (const vrange &) const override; +}; + +// Traits to implement vrange is_a<> and as_a<>. + +template +struct vrange_traits +{ + // Default to something unusable. + typedef void range_type; +}; + +template<> +struct vrange_traits +{ + typedef irange range_type; +}; + +template +inline bool +is_a (vrange &v) +{ + gcc_unreachable (); + return false; +} + +template +inline bool +is_a (const vrange &v) +{ + // Reuse is_a to implement the const version. + const T &derived = static_cast (v); + return is_a (const_cast (derived)); +} + +template +inline T & +as_a (vrange &v) +{ + typedef typename vrange_traits::range_type range_type; + gcc_checking_assert (is_a (v)); + return static_cast (v); +} + +template +inline const T & +as_a (const vrange &v) +{ + typedef typename vrange_traits::range_type range_type; + gcc_checking_assert (is_a (v)); + return static_cast (v); +} + +// Specializations for the different range types. + +template <> +inline bool +is_a (vrange &v) +{ + return v.m_discriminator == VR_IRANGE; +} + // This is a special int_range<1> with only one pair, plus // VR_ANTI_RANGE magic to describe slightly more than can be described // in one pair. It is described in the code as a "legacy range" (as @@ -197,13 +323,13 @@ irange::legacy_mode_p () const extern bool range_has_numeric_bounds_p (const irange *); extern bool ranges_from_anti_range (const value_range *, value_range *, value_range *); -extern void dump_value_range (FILE *, const irange *); +extern void dump_value_range (FILE *, const vrange *); extern bool vrp_val_is_min (const_tree); extern bool vrp_val_is_max (const_tree); extern bool vrp_operand_equal_p (const_tree, const_tree); inline value_range_kind -irange::kind () const +vrange::kind () const { return m_kind; } @@ -293,13 +419,13 @@ irange::varying_compatible_p () const } inline bool -irange::varying_p () const +vrange::varying_p () const { return m_kind == VR_VARYING; } inline bool -irange::undefined_p () const +vrange::undefined_p () const { return m_kind == VR_UNDEFINED; } @@ -398,6 +524,7 @@ gt_pch_nx (int_range *x, gt_pointer_operator op, void *cookie) inline irange::irange (tree *base, unsigned nranges) { + m_discriminator = VR_IRANGE; m_base = base; m_max_ranges = nranges; set_undefined (); @@ -547,21 +674,21 @@ irange::upper_bound () const } inline bool -irange::union_ (const irange &r) +irange::union_ (const vrange &r) { dump_flags_t m_flags = dump_flags; dump_flags &= ~TDF_DETAILS; - bool ret = irange::legacy_verbose_union_ (&r); + bool ret = irange::legacy_verbose_union_ (&as_a (r)); dump_flags = m_flags; return ret; } inline bool -irange::intersect (const irange &r) +irange::intersect (const vrange &r) { dump_flags_t m_flags = dump_flags; dump_flags &= ~TDF_DETAILS; - bool ret = irange::legacy_verbose_intersect (&r); + bool ret = irange::legacy_verbose_intersect (&as_a (r)); dump_flags = m_flags; return ret; } @@ -608,6 +735,12 @@ irange::normalize_kind () } } +inline bool +vrange::supports_type_p (tree type) +{ + return irange::supports_type_p (type); +} + // Return the maximum value for TYPE. inline tree diff --git a/gcc/vr-values.cc b/gcc/vr-values.cc index 47faa4ff938..6f8583c8d01 100644 --- a/gcc/vr-values.cc +++ b/gcc/vr-values.cc @@ -883,7 +883,7 @@ vr_values::extract_range_from_binary_expr (value_range_equiv *vr, wide_int wmax = wi::to_wide (max, TYPE_PRECISION (TREE_TYPE (max))); tree range_min = build_zero_cst (expr_type); tree range_max = wide_int_to_tree (expr_type, wmax - 1); - vr->set (range_min, range_max); + vr->set (range_min, range_max, NULL); return; } } @@ -1275,7 +1275,7 @@ vr_values::extract_range_basic (value_range_equiv *vr, gimple *stmt) /* This is the boolean return value whether compare and exchange changed anything or not. */ vr->set (build_int_cst (type, 0), - build_int_cst (type, 1)); + build_int_cst (type, 1), NULL); return; } break; @@ -1297,7 +1297,7 @@ vr_values::extract_range_basic (value_range_equiv *vr, gimple *stmt) vr->set_varying (type); else vr->set (build_int_cst (type, 0), - build_int_cst (type, 1)); + build_int_cst (type, 1), NULL); } else if (types_compatible_p (type, TREE_TYPE (op0)) && types_compatible_p (type, TREE_TYPE (op1)))