d: Import dmd b8384668f, druntime e6caaab9, phobos 5ab9ad256 (v2.098.0-beta.1)

The D front-end is now itself written in D, in order to build GDC, you
will need a working GDC compiler (GCC version 9.1 or later).

GCC changes:

    - Add support for bootstrapping the D front-end.

These add the required components in order to have a D front-end written
in D itself.  Because the compiler front-end only depends on the core
runtime modules, only libdruntime is built for the bootstrap stages.

D front-end changes:

    - Import dmd v2.098.0-beta.1.

Druntime changes:

    - Import druntime v2.098.0-beta.1.

Phobos changes:

    - Import phobos v2.098.0-beta.1.

The jump from v2.076.1 to v2.098.0 covers nearly 4 years worth of
development on the D programming language and run-time libraries.

ChangeLog:

	* Makefile.def: Add bootstrap to libbacktrace, libphobos, zlib, and
	libatomic.
	* Makefile.in: Regenerate.
	* Makefile.tpl (POSTSTAGE1_HOST_EXPORTS): Fix command for GDC.
	(STAGE1_CONFIGURE_FLAGS): Add --with-libphobos-druntime-only if
	target-libphobos-bootstrap.
	(STAGE2_CONFIGURE_FLAGS): Likewise.
	* configure: Regenerate.
	* configure.ac: Add support for bootstrapping D front-end.

config/ChangeLog:

	* acx.m4 (ACX_PROG_GDC): New m4 function.

gcc/ChangeLog:

	* Makefile.in (GDC): New variable.
	(GDCFLAGS): New variable.
	* configure: Regenerate.
	* configure.ac: Add call to ACX_PROG_GDC.  Substitute GDCFLAGS.

gcc/d/ChangeLog:

	* dmd/MERGE: Merge upstream dmd b8384668f.
	* Make-lang.in (d-warn): Use strict warnings.
	(DMD_WARN_CXXFLAGS): Remove.
	(DMD_COMPILE): Remove.
	(CHECKING_DFLAGS): Define.
	(WARN_DFLAGS): Define.
	(ALL_DFLAGS): Define.
	(DCOMPILE.base): Define.
	(DCOMPILE): Define.
	(DPOSTCOMPILE): Define.
	(DLINKER): Define.
	(DLLINKER): Define.
	(D_FRONTEND_OBJS): Add new dmd front-end objects.
	(D_GENERATED_SRCS): Remove.
	(D_GENERATED_OBJS): Remove.
	(D_ALL_OBJS): Remove D_GENERATED_OBJS.
	(d21$(exeext)): Build using DLLINKER and -static-libphobos.
	(d.tags): Remove dmd/*.c and dmd/root/*.c.
	(d.mostlyclean): Remove D_GENERATED_SRCS, d/idgen$(build_exeext),
	d/impcnvgen$(build_exeext).
	(D_INCLUDES): Include $(srcdir)/d/dmd/res.
	(CFLAGS-d/id.o): Remove.
	(CFLAGS-d/impcnvtab.o): Remove.
	(d/%.o): Build using DCOMPILE and DPOSTCOMPILE.  Update dependencies
	from d/dmd/%.c to d/dmd/%.d.
	(d/idgen$(build_exeext)): Remove.
	(d/impcnvgen$(build_exeext)): Remove.
	(d/id.c): Remove.
	(d/id.h): Remove.
	(d/impcnvtab.c): Remove.
	(d/%.dmdgen.o): Remove.
	(D_SYSTEM_H): Remove.
	(d/idgen.dmdgen.o): Remove.
	(d/impcnvgen.dmdgen.o): Remove.
	* config-lang.in (boot_language): New variable.
	* d-attribs.cc: Include dmd/expression.h.
	* d-builtins.cc: Include d-frontend.h.
	(build_frontend_type): Update for new front-end interface.
	(d_eval_constant_expression): Likewise.
	(d_build_builtins_module): Likewise.
	(maybe_set_builtin_1): Likewise.
	(d_build_d_type_nodes): Likewise.
	* d-codegen.cc (d_decl_context): Likewise.
	(declaration_reference_p): Likewise.
	(declaration_type): Likewise.
	(parameter_reference_p): Likewise.
	(parameter_type): Likewise.
	(get_array_length): Likewise.
	(build_delegate_cst): Likewise.
	(build_typeof_null_value): Likewise.
	(identity_compare_p): Likewise.
	(lower_struct_comparison): Likewise.
	(build_filename_from_loc): Likewise.
	(build_assert_call): Remove LIBCALL_SWITCH_ERROR.
	(build_bounds_index_condition): Call LIBCALL_ARRAYBOUNDS_INDEXP on
	bounds error.
	(build_bounds_slice_condition): Call LIBCALL_ARRAYBOUNDS_SLICEP on
	bounds error.
	(array_bounds_check): Update for new front-end interface.
	(checkaction_trap_p): Handle CHECKACTION_context.
	(get_function_type): Update for new front-end interface.
	(d_build_call): Likewise.
	* d-compiler.cc: Remove include of dmd/scope.h.
	(Compiler::genCmain): Remove.
	(Compiler::paintAsType): Update for new front-end interface.
	(Compiler::onParseModule): Likewise.
	* d-convert.cc (convert_expr): Remove call to LIBCALL_ARRAYCAST.
	(convert_for_rvalue): Update for new front-end interface.
	(convert_for_assignment): Likewise.
	(convert_for_condition): Likewise.
	(d_array_convert): Likewise.
	* d-diagnostic.cc (error): Remove.
	(errorSupplemental): Remove.
	(warning): Remove.
	(warningSupplemental): Remove.
	(deprecation): Remove.
	(deprecationSupplemental): Remove.
	(message): Remove.
	(vtip): New.
	* d-frontend.cc (global): Remove.
	(Global::_init): Remove.
	(Global::startGagging): Remove.
	(Global::endGagging): Remove.
	(Global::increaseErrorCount): Remove.
	(Loc::Loc): Remove.
	(Loc::toChars): Remove.
	(Loc::equals): Remove.
	(isBuiltin): Update for new front-end interface.
	(eval_builtin): Likewise.
	(getTypeInfoType): Likewise.
	(inlineCopy): Remove.
	* d-incpath.cc: Include d-frontend.h.
	(add_globalpaths): Call d_gc_malloc to allocate Strings.
	(add_filepaths): Likewise.
	* d-lang.cc: Include dmd/id.h, dmd/root/file.h, d-frontend.h.  Remove
	include of dmd/mars.h, id.h.
	(entrypoint_module): Remove.
	(entrypoint_root_module): Remove.
	(deps_write_string): Update for new front-end interface.
	(deps_write): Likewise.
	(d_init_options): Call rt_init.  Remove setting global params that are
	default initialized by the front-end.
	(d_handle_option): Handle OPT_fcheckaction_, OPT_fdump_c___spec_,
	OPT_fdump_c___spec_verbose, OPT_fextern_std_, OPT_fpreview,
	OPT_revert, OPT_fsave_mixins_, and OPT_ftransition.
	(d_post_options): Propagate dip1021 and dip1000 preview flags to
	dip25, and flag_diagnostics_show_caret to printErrorContext.
	(d_add_entrypoint_module): Remove.
	(d_parse_file): Update for new front-end interface.
	(d_type_promotes_to): Likewise.
	(d_types_compatible_p): Likewise.
	* d-longdouble.cc (CTFloat::zero): Remove.
	(CTFloat::one): Remove.
	(CTFloat::minusone): Remove.
	(CTFloat::half): Remove.
	* d-system.h (POSIX): Remove.
	(realpath): Remove.
	(isalpha): Remove.
	(isalnum): Remove.
	(isdigit): Remove.
	(islower): Remove.
	(isprint): Remove.
	(isspace): Remove.
	(isupper): Remove.
	(isxdigit): Remove.
	(tolower): Remove.
	(_mkdir): Remove.
	(INT32_MAX): Remove.
	(INT32_MIN): Remove.
	(INT64_MIN): Remove.
	(UINT32_MAX): Remove.
	(UINT64_MAX): Remove.
	* d-target.cc: Include calls.h.
	(target): Remove.
	(define_float_constants): Remove initialization of snan.
	(Target::_init): Update for new front-end interface.
	(Target::isVectorTypeSupported): Likewise.
	(Target::isVectorOpSupported): Remove cases for unordered operators.
	(TargetCPP::typeMangle): Update for new front-end interface.
	(TargetCPP::parameterType): Likewise.
	(Target::systemLinkage): Likewise.
	(Target::isReturnOnStack): Likewise.
	(Target::isCalleeDestroyingArgs): Define.
	(Target::preferPassByRef): Define.
	* d-tree.h (d_add_entrypoint_module): Remove.
	* decl.cc (gcc_attribute_p): Update for new front-end interface.
	(apply_pragma_crt): Define.
	(DeclVisitor::visit(PragmaDeclaration *)): Handle pragmas
	crt_constructor and crt_destructor.
	(DeclVisitor::visit(TemplateDeclaration *)): Update for new front-end
	interface.
	(DeclVisitor::visit): Likewise.
	(DeclVisitor::finish_vtable): Likewise.
	(get_symbol_decl): Error if template has more than one nesting
	context.  Update for new front-end interface.
	(make_thunk): Update for new front-end interface.
	(get_vtable_decl): Likewise.
	* expr.cc (ExprVisitor::visit): Likewise.
	(build_return_dtor): Likewise.
	* imports.cc (ImportVisitor::visit): Likewise.
	* intrinsics.cc: Include dmd/expression.h.  Remove include of
	dmd/mangle.h.
	(maybe_set_intrinsic): Update for new front-end interface.
	* intrinsics.def (INTRINSIC_ROL): Update intrinsic signature.
	(INTRINSIC_ROR): Likewise.
	(INTRINSIC_ROR_TIARG): Likewise.
	(INTRINSIC_TOPREC): Likewise.
	(INTRINSIC_TOPRECL): Likewise.
	(INTRINSIC_TAN): Update intrinsic module and signature.
	(INTRINSIC_ISNAN): Likewise.
	(INTRINSIC_ISFINITE): Likewise.
	(INTRINSIC_COPYSIGN): Define intrinsic.
	(INTRINSIC_COPYSIGNI): Define intrinsic.
	(INTRINSIC_EXP): Update intrinsic module.
	(INTRINSIC_EXPM1): Likewise.
	(INTRINSIC_EXP2): Likewise.
	(INTRINSIC_LOG): Likewise.
	(INTRINSIC_LOG2): Likewise.
	(INTRINSIC_LOG10): Likewise.
	(INTRINSIC_POW): Likewise.
	(INTRINSIC_ROUND): Likewise.
	(INTRINSIC_FLOORF): Likewise.
	(INTRINSIC_FLOOR): Likewise.
	(INTRINSIC_FLOORL): Likewise.
	(INTRINSIC_CEILF): Likewise.
	(INTRINSIC_CEIL): Likewise.
	(INTRINSIC_CEILL): Likewise.
	(INTRINSIC_TRUNC): Likewise.
	(INTRINSIC_FMIN): Likewise.
	(INTRINSIC_FMAX): Likewise.
	(INTRINSIC_FMA): Likewise.
	(INTRINSIC_VA_ARG): Update intrinsic signature.
	(INTRINSIC_VASTART): Likewise.
	* lang.opt (fcheck=): Add alternate aliases for contract switches.
	(fcheckaction=): New option.
	(check_action): New Enum and EnumValue entries.
	(fdump-c++-spec-verbose): New option.
	(fdump-c++-spec=): New option.
	(fextern-std=): New option.
	(extern_stdcpp): New Enum and EnumValue entries
	(fpreview=): New options.
	(frevert=): New options.
	(fsave-mixins): New option.
	(ftransition=): Update options.
	* modules.cc (get_internal_fn): Replace Prot with Visibility.
	(build_internal_fn): Likewise.
	(build_dso_cdtor_fn): Likewise.
	(build_module_tree): Remove check for __entrypoint module.
	* runtime.def (P5): Define.
	(ARRAYBOUNDS_SLICEP): Define.
	(ARRAYBOUNDS_INDEXP): Define.
	(NEWTHROW): Define.
	(ADCMP2): Remove.
	(ARRAYCAST): Remove.
	(SWITCH_STRING): Remove.
	(SWITCH_USTRING): Remove.
	(SWITCH_DSTRING): Remove.
	(SWITCH_ERROR): Remove.
	* toir.cc (IRVisitor::visit): Update for new front-end interface.
	(IRVisitor::check_previous_goto): Remove checks for case and default
	statements.
	(IRVisitor::visit(SwitchStatement *)): Remove handling of string
	switch conditions.
	* typeinfo.cc: Include d-frontend.h.
	(get_typeinfo_kind): Update for new front-end interface.
	(make_frontend_typeinfo): Likewise.
	(TypeInfoVisitor::visit): Likewise.
	(builtin_typeinfo_p): Likewise.
	(get_typeinfo_decl): Likewise.
	(build_typeinfo): Likewise.
	* types.cc (valist_array_p): Likewise.
	(make_array_type): Likewise.
	(merge_aggregate_types): Likewise.
	(TypeVisitor::visit(TypeBasic *)): Likewise.
	(TypeVisitor::visit(TypeFunction *)): Likewise.
	(TypeVisitor::visit(TypeStruct *)): Update comment.
	* verstr.h: Removed.
	* d-frontend.h: New file.

gcc/po/ChangeLog:

	* EXCLUDES: Remove d/dmd sources from list.

gcc/testsuite/ChangeLog:

	* gdc.dg/Wcastresult2.d: Update test.
	* gdc.dg/asm1.d: Likewise.
	* gdc.dg/asm2.d: Likewise.
	* gdc.dg/asm3.d: Likewise.
	* gdc.dg/gdc282.d: Likewise.
	* gdc.dg/imports/gdc170.d: Likewise.
	* gdc.dg/intrinsics.d: Likewise.
	* gdc.dg/pr101672.d: Likewise.
	* gdc.dg/pr90650a.d: Likewise.
	* gdc.dg/pr90650b.d: Likewise.
	* gdc.dg/pr94777a.d: Likewise.
	* gdc.dg/pr95250.d: Likewise.
	* gdc.dg/pr96869.d: Likewise.
	* gdc.dg/pr98277.d: Likewise.
	* gdc.dg/pr98457.d: Likewise.
	* gdc.dg/simd1.d: Likewise.
	* gdc.dg/simd2a.d: Likewise.
	* gdc.dg/simd2b.d: Likewise.
	* gdc.dg/simd2c.d: Likewise.
	* gdc.dg/simd2d.d: Likewise.
	* gdc.dg/simd2e.d: Likewise.
	* gdc.dg/simd2f.d: Likewise.
	* gdc.dg/simd2g.d: Likewise.
	* gdc.dg/simd2h.d: Likewise.
	* gdc.dg/simd2i.d: Likewise.
	* gdc.dg/simd2j.d: Likewise.
	* gdc.dg/simd7951.d: Likewise.
	* gdc.dg/torture/gdc309.d: Likewise.
	* gdc.dg/torture/pr94424.d: Likewise.
	* gdc.dg/torture/pr94777b.d: Likewise.
	* lib/gdc-utils.exp (gdc-convert-args): Handle new compiler options.
	(gdc-convert-test): Handle CXXFLAGS, EXTRA_OBJC_SOURCES, and ARG_SETS
	test directives.
	(gdc-do-test): Only import modules in the test run directory.
	* gdc.dg/pr94777c.d: New test.
	* gdc.dg/pr96156b.d: New test.
	* gdc.dg/pr96157c.d: New test.
	* gdc.dg/simd_ctfe.d: New test.
	* gdc.dg/torture/simd17344.d: New test.
	* gdc.dg/torture/simd20052.d: New test.
	* gdc.dg/torture/simd6.d: New test.
	* gdc.dg/torture/simd7.d: New test.

libphobos/ChangeLog:

	* libdruntime/MERGE: Merge upstream druntime e6caaab9.
	* libdruntime/Makefile.am (D_EXTRA_FLAGS): Build libdruntime with
	-fpreview=dip1000, -fpreview=fieldwise, and -fpreview=dtorfields.
	(ALL_DRUNTIME_SOURCES): Add DRUNTIME_DSOURCES_STDCXX.
	(DRUNTIME_DSOURCES): Update list of C binding modules.
	(DRUNTIME_DSOURCES_STDCXX): Likewise.
	(DRUNTIME_DSOURCES_LINUX): Likewise.
	(DRUNTIME_DSOURCES_OPENBSD): Likewise.
	(DRUNTIME_DISOURCES): Remove __entrypoint.di.
	* libdruntime/Makefile.in: Regenerated.
	* libdruntime/__entrypoint.di: Removed.
	* libdruntime/gcc/deh.d (_d_isbaseof): Update signature.
	(_d_createTrace): Likewise.
	(__gdc_begin_catch): Remove reference to the exception.
	(_d_throw): Increment reference count of thrown object before unwind.
	(__gdc_personality): Chain exceptions with  Throwable.chainTogether.
	* libdruntime/gcc/emutls.d: Update imports.
	* libdruntime/gcc/sections/elf.d: Update imports.
	(DSO.moduleGroup): Update signature.
	* libdruntime/gcc/sections/macho.d: Update imports.
	(DSO.moduleGroup): Update signature.
	* libdruntime/gcc/sections/pecoff.d: Update imports.
	(DSO.moduleGroup): Update signature.
	* src/MERGE: Merge upstream phobos 5ab9ad256.
	* src/Makefile.am (D_EXTRA_DFLAGS): Add -fpreview=dip1000 and
	-fpreview=dtorfields flags.
	(PHOBOS_DSOURCES): Update list of std modules.
	* src/Makefile.in: Regenerate.
	* testsuite/lib/libphobos.exp (libphobos-dg-test): Handle assembly
	compile types.
	(dg-test): Override.
	(additional_prunes): Define.
	(libphobos-dg-prune): Filter any additional_prunes set by tests.
	* testsuite/libphobos.aa/test_aa.d: Update test.
	* testsuite/libphobos.druntime/druntime.exp (version_flags): Add
	-fversion=CoreUnittest.
	* testsuite/libphobos.druntime_shared/druntime_shared.exp
	(version_flags): Add -fversion=CoreUnittest -fversion=Shared.
	* testsuite/libphobos.exceptions/unknown_gc.d: Update test.
	* testsuite/libphobos.hash/test_hash.d: Update test.
	* testsuite/libphobos.phobos/phobos.exp (version_flags): Add
	-fversion=StdUnittest
	* testsuite/libphobos.phobos_shared/phobos_shared.exp (version_flags):
	Likewise.
	* testsuite/libphobos.shared/host.c: Update test.
	* testsuite/libphobos.shared/load.d: Update test.
	* testsuite/libphobos.shared/load_13414.d: Update test.
	* testsuite/libphobos.thread/fiber_guard_page.d: Update test.
	* testsuite/libphobos.thread/tlsgc_sections.d: Update test.
	* testsuite/testsuite_flags.in: Add -fpreview=dip1000 to --gdcflags.
	* testsuite/libphobos.shared/link_mod_collision.d: Removed.
	* testsuite/libphobos.shared/load_mod_collision.d: Removed.
	* testsuite/libphobos.betterc/betterc.exp: New test.
	* testsuite/libphobos.config/config.exp: New test.
	* testsuite/libphobos.gc/gc.exp: New test.
	* testsuite/libphobos.imports/imports.exp: New test.
	* testsuite/libphobos.lifetime/lifetime.exp: New test.
	* testsuite/libphobos.unittest/unittest.exp: New test.

1 files changed, 0 insertions, 839 deletions

diff --git a/gcc/d/dmd/intrange.c b/gcc/d/dmd/intrange.c
deleted file mode 100644
index 36af8da..0000000
--- a/gcc/d/dmd/intrange.c
+++ /dev/null
@@ -1,839 +0,0 @@
-
-/* Compiler implementation of the D programming language
- * Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
- * written by KennyTM
- * http://www.digitalmars.com
- * Distributed under the Boost Software License, Version 1.0.
- * http://www.boost.org/LICENSE_1_0.txt
- * https://github.com/D-Programming-Language/dmd/blob/master/src/intrange.c
- */
-
-#include "root/dsystem.h"
-
-#include "intrange.h"
-#include "mars.h"
-#include "mtype.h"
-#include "expression.h"
-
-// Copy the sign to the value *x*. Equivalent to `sign ? -x : x`.
-static uinteger_t copySign(uinteger_t x, bool sign)
-{
-    // return sign ? -x : x;
-    return (x - (uinteger_t)sign) ^ -(uinteger_t)sign;
-}
-
-#ifndef UINT64_MAX
-#define UINT64_MAX 0xFFFFFFFFFFFFFFFFULL
-#endif
-
-//==================== SignExtendedNumber ======================================
-
-SignExtendedNumber SignExtendedNumber::fromInteger(uinteger_t value_)
-{
-    return SignExtendedNumber(value_, value_ >> 63);
-}
-
-bool SignExtendedNumber::operator==(const SignExtendedNumber& a) const
-{
-    return value == a.value && negative == a.negative;
-}
-
-bool SignExtendedNumber::operator<(const SignExtendedNumber& a) const
-{
-    return (negative && !a.negative)
-        || (negative == a.negative && value < a.value);
-}
-
-SignExtendedNumber SignExtendedNumber::extreme(bool minimum)
-{
-    return SignExtendedNumber(minimum-1, minimum);
-}
-
-SignExtendedNumber SignExtendedNumber::max()
-{
-    return SignExtendedNumber(UINT64_MAX, false);
-}
-
-SignExtendedNumber& SignExtendedNumber::operator++()
-{
-    if (value != UINT64_MAX)
-        ++value;
-    else if (negative)
-    {
-        value = 0;
-        negative = false;
-    }
-    return *this;
-}
-
-SignExtendedNumber SignExtendedNumber::operator~() const
-{
-    if (~value == 0)
-        return SignExtendedNumber(~value);
-    else
-        return SignExtendedNumber(~value, !negative);
-}
-
-SignExtendedNumber SignExtendedNumber::operator-() const
-{
-    if (value == 0)
-        return SignExtendedNumber(-negative);
-    else
-        return SignExtendedNumber(-value, !negative);
-}
-
-SignExtendedNumber SignExtendedNumber::operator&(const SignExtendedNumber& rhs) const
-{
-    return SignExtendedNumber(value & rhs.value);
-}
-
-SignExtendedNumber SignExtendedNumber::operator|(const SignExtendedNumber& rhs) const
-{
-    return SignExtendedNumber(value | rhs.value);
-}
-
-SignExtendedNumber SignExtendedNumber::operator^(const SignExtendedNumber& rhs) const
-{
-    return SignExtendedNumber(value ^ rhs.value);
-}
-
-SignExtendedNumber SignExtendedNumber::operator+(const SignExtendedNumber& rhs) const
-{
-    uinteger_t sum = value + rhs.value;
-    bool carry = sum < value && sum < rhs.value;
-    if (negative != rhs.negative)
-        return SignExtendedNumber(sum, !carry);
-    else if (negative)
-        return SignExtendedNumber(carry ? sum : 0, true);
-    else
-        return SignExtendedNumber(carry ? UINT64_MAX : sum, false);
-}
-
-SignExtendedNumber SignExtendedNumber::operator-(const SignExtendedNumber& rhs) const
-{
-    if (rhs.isMinimum())
-        return negative ? SignExtendedNumber(value, false) : max();
-    else
-        return *this + (-rhs);
-}
-
-SignExtendedNumber SignExtendedNumber::operator*(const SignExtendedNumber& rhs) const
-{
-    // perform *saturated* multiplication, otherwise we may get bogus ranges
-    //  like 0x10 * 0x10 == 0x100 == 0.
-
-    /* Special handling for zeros:
-        INT65_MIN * 0 = 0
-        INT65_MIN * + = INT65_MIN
-        INT65_MIN * - = INT65_MAX
-        0 * anything = 0
-    */
-    if (value == 0)
-    {
-        if (!negative)
-            return *this;
-        else if (rhs.negative)
-            return max();
-        else
-            return rhs.value == 0 ? rhs : *this;
-    }
-    else if (rhs.value == 0)
-        return rhs * *this;   // don't duplicate the symmetric case.
-
-    SignExtendedNumber rv;
-    // these are != 0 now surely.
-    uinteger_t tAbs = copySign(value, negative);
-    uinteger_t aAbs = copySign(rhs.value, rhs.negative);
-    rv.negative = negative != rhs.negative;
-    if (UINT64_MAX / tAbs < aAbs)
-        rv.value = rv.negative-1;
-    else
-        rv.value = copySign(tAbs * aAbs, rv.negative);
-    return rv;
-}
-
-SignExtendedNumber SignExtendedNumber::operator/(const SignExtendedNumber& rhs) const
-{
-    /* special handling for zeros:
-        INT65_MIN / INT65_MIN = 1
-        anything / INT65_MIN = 0
-        + / 0 = INT65_MAX  (eh?)
-        - / 0 = INT65_MIN  (eh?)
-    */
-    if (rhs.value == 0)
-    {
-        if (rhs.negative)
-            return SignExtendedNumber(value == 0 && negative);
-        else
-            return extreme(negative);
-    }
-
-    uinteger_t aAbs = copySign(rhs.value, rhs.negative);
-    uinteger_t rvVal;
-
-    if (!isMinimum())
-        rvVal = copySign(value, negative) / aAbs;
-    // Special handling for INT65_MIN
-    //  if the denominator is not a power of 2, it is same as UINT64_MAX / x.
-    else if (aAbs & (aAbs-1))
-        rvVal = UINT64_MAX / aAbs;
-    // otherwise, it's the same as reversing the bits of x.
-    else
-    {
-        if (aAbs == 1)
-            return extreme(!rhs.negative);
-        rvVal = 1ULL << 63;
-        aAbs >>= 1;
-        if (aAbs & 0xAAAAAAAAAAAAAAAAULL) rvVal >>= 1;
-        if (aAbs & 0xCCCCCCCCCCCCCCCCULL) rvVal >>= 2;
-        if (aAbs & 0xF0F0F0F0F0F0F0F0ULL) rvVal >>= 4;
-        if (aAbs & 0xFF00FF00FF00FF00ULL) rvVal >>= 8;
-        if (aAbs & 0xFFFF0000FFFF0000ULL) rvVal >>= 16;
-        if (aAbs & 0xFFFFFFFF00000000ULL) rvVal >>= 32;
-    }
-    bool rvNeg = negative != rhs.negative;
-    rvVal = copySign(rvVal, rvNeg);
-
-    return SignExtendedNumber(rvVal, rvVal != 0 && rvNeg);
-}
-
-SignExtendedNumber SignExtendedNumber::operator%(const SignExtendedNumber& rhs) const
-{
-    if (rhs.value == 0)
-        return !rhs.negative ? rhs : isMinimum() ? SignExtendedNumber(0) : *this;
-
-    uinteger_t aAbs = copySign(rhs.value, rhs.negative);
-    uinteger_t rvVal;
-
-    // a % b == sgn(a) * abs(a) % abs(b).
-    if (!isMinimum())
-        rvVal = copySign(value, negative) % aAbs;
-    // Special handling for INT65_MIN
-    //  if the denominator is not a power of 2, it is same as UINT64_MAX%x + 1.
-    else if (aAbs & (aAbs - 1))
-        rvVal = UINT64_MAX % aAbs + 1;
-    //  otherwise, the modulus is trivially zero.
-    else
-        rvVal = 0;
-
-    rvVal = copySign(rvVal, negative);
-    return SignExtendedNumber(rvVal, rvVal != 0 && negative);
-}
-
-SignExtendedNumber SignExtendedNumber::operator<<(const SignExtendedNumber& rhs) const
-{
-    // assume left-shift the shift-amount is always unsigned. Thus negative
-    //  shifts will give huge result.
-    if (value == 0)
-        return *this;
-    else if (rhs.negative)
-        return extreme(negative);
-
-    uinteger_t v = copySign(value, negative);
-
-    // compute base-2 log of 'v' to determine the maximum allowed bits to shift.
-    // Ref: http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
-
-    // Why is this a size_t? Looks like a bug.
-    size_t r, s;
-
-    r = (v > 0xFFFFFFFFULL) << 5; v >>= r;
-    s = (v > 0xFFFFULL    ) << 4; v >>= s; r |= s;
-    s = (v > 0xFFULL      ) << 3; v >>= s; r |= s;
-    s = (v > 0xFULL       ) << 2; v >>= s; r |= s;
-    s = (v > 0x3ULL       ) << 1; v >>= s; r |= s;
-                                           r |= (v >> 1);
-
-    uinteger_t allowableShift = 63 - r;
-    if (rhs.value > allowableShift)
-        return extreme(negative);
-    else
-        return SignExtendedNumber(value << rhs.value, negative);
-}
-
-SignExtendedNumber SignExtendedNumber::operator>>(const SignExtendedNumber& rhs) const
-{
-    if (rhs.negative || rhs.value > 63)
-        return negative ? SignExtendedNumber(-1, true) : SignExtendedNumber(0);
-    else if (isMinimum())
-        return rhs.value == 0 ? *this : SignExtendedNumber(-1ULL << (64 - rhs.value), true);
-
-    uinteger_t x = value ^ -negative;
-    x >>= rhs.value;
-    return SignExtendedNumber(x ^ -negative, negative);
-}
-
-
-//==================== IntRange ================================================
-
-IntRange IntRange::widest()
-{
-    return IntRange(SignExtendedNumber::min(), SignExtendedNumber::max());
-}
-
-IntRange IntRange::fromType(Type *type)
-{
-    return fromType(type, type->isunsigned());
-}
-
-IntRange IntRange::fromType(Type *type, bool isUnsigned)
-{
-    if (!type->isintegral() || type->toBasetype()->ty == Tvector)
-        return widest();
-
-    uinteger_t mask = type->sizemask();
-    SignExtendedNumber lower(0), upper(mask);
-    if (type->toBasetype()->ty == Tdchar)
-        upper.value = 0x10FFFFULL;
-    else if (!isUnsigned)
-    {
-        lower.value = ~(mask >> 1);
-        lower.negative = true;
-        upper.value = (mask >> 1);
-    }
-    return IntRange(lower, upper);
-}
-
-IntRange IntRange::fromNumbers2(const SignExtendedNumber numbers[2])
-{
-    if (numbers[0] < numbers[1])
-        return IntRange(numbers[0], numbers[1]);
-    else
-        return IntRange(numbers[1], numbers[0]);
-}
-IntRange IntRange::fromNumbers4(const SignExtendedNumber numbers[4])
-{
-    IntRange ab = fromNumbers2(numbers);
-    IntRange cd = fromNumbers2(numbers + 2);
-    if (cd.imin < ab.imin)
-        ab.imin = cd.imin;
-    if (cd.imax > ab.imax)
-        ab.imax = cd.imax;
-    return ab;
-}
-
-bool IntRange::contains(const IntRange& a) const
-{
-    return imin <= a.imin && imax >= a.imax;
-}
-
-bool IntRange::containsZero() const
-{
-    return (imin.negative && !imax.negative)
-        || (!imin.negative && imin.value == 0);
-}
-
-IntRange& IntRange::castUnsigned(uinteger_t mask)
-{
-    // .... 0x1eff ] [0x1f00 .. 0x1fff] [0 .. 0xff] [0x100 .. 0x1ff] [0x200 ....
-    //
-    // regular unsigned type. We just need to see if ir steps across the
-    //  boundary of validRange. If yes, ir will represent the whole validRange,
-    //  otherwise, we just take the modulus.
-    // e.g. [0x105, 0x107] & 0xff == [5, 7]
-    //      [0x105, 0x207] & 0xff == [0, 0xff]
-    uinteger_t minChunk = imin.value & ~mask;
-    uinteger_t maxChunk = imax.value & ~mask;
-    if (minChunk == maxChunk && imin.negative == imax.negative)
-    {
-        imin.value &= mask;
-        imax.value &= mask;
-    }
-    else
-    {
-        imin.value = 0;
-        imax.value = mask;
-    }
-    imin.negative = imax.negative = false;
-    return *this;
-}
-
-IntRange& IntRange::castSigned(uinteger_t mask)
-{
-    // .... 0x1e7f ] [0x1e80 .. 0x1f7f] [0x1f80 .. 0x7f] [0x80 .. 0x17f] [0x180 ....
-    //
-    // regular signed type. We use a technique similar to the unsigned version,
-    //  but the chunk has to be offset by 1/2 of the range.
-    uinteger_t halfChunkMask = mask >> 1;
-    uinteger_t minHalfChunk = imin.value & ~halfChunkMask;
-    uinteger_t maxHalfChunk = imax.value & ~halfChunkMask;
-    int minHalfChunkNegativity = imin.negative; // 1 = neg, 0 = nonneg, -1 = chunk containing ::max
-    int maxHalfChunkNegativity = imax.negative;
-    if (minHalfChunk & mask)
-    {
-        minHalfChunk += halfChunkMask+1;
-        if (minHalfChunk == 0)
-            -- minHalfChunkNegativity;
-    }
-    if (maxHalfChunk & mask)
-    {
-        maxHalfChunk += halfChunkMask+1;
-        if (maxHalfChunk == 0)
-            -- maxHalfChunkNegativity;
-    }
-    if (minHalfChunk == maxHalfChunk && minHalfChunkNegativity == maxHalfChunkNegativity)
-    {
-        imin.value &= mask;
-        imax.value &= mask;
-        // sign extend if necessary.
-        imin.negative = imin.value & ~halfChunkMask;
-        imax.negative = imax.value & ~halfChunkMask;
-        halfChunkMask += 1;
-        imin.value = (imin.value ^ halfChunkMask) - halfChunkMask;
-        imax.value = (imax.value ^ halfChunkMask) - halfChunkMask;
-    }
-    else
-    {
-        imin = SignExtendedNumber(~halfChunkMask, true);
-        imax = SignExtendedNumber(halfChunkMask, false);
-    }
-    return *this;
-}
-
-IntRange& IntRange::castDchar()
-{
-    // special case for dchar. Casting to dchar means "I'll ignore all
-    //  invalid characters."
-    castUnsigned(0xFFFFFFFFULL);
-    if (imin.value > 0x10FFFFULL)   // ??
-        imin.value = 0x10FFFFULL;   // ??
-    if (imax.value > 0x10FFFFULL)
-        imax.value = 0x10FFFFULL;
-    return *this;
-}
-
-IntRange& IntRange::cast(Type *type)
-{
-    if (!type->isintegral() || type->toBasetype()->ty == Tvector)
-        return *this;
-    else if (!type->isunsigned())
-        return castSigned(type->sizemask());
-    else if (type->toBasetype()->ty == Tdchar)
-        return castDchar();
-    else
-        return castUnsigned(type->sizemask());
-}
-
-IntRange& IntRange::castUnsigned(Type *type)
-{
-    if (!type->isintegral() || type->toBasetype()->ty == Tvector)
-        return castUnsigned(UINT64_MAX);
-    else if (type->toBasetype()->ty == Tdchar)
-        return castDchar();
-    else
-        return castUnsigned(type->sizemask());
-}
-
-IntRange IntRange::absNeg() const
-{
-    if (imax.negative)
-        return *this;
-    else if (!imin.negative)
-        return IntRange(-imax, -imin);
-    else
-    {
-        SignExtendedNumber imaxAbsNeg = -imax;
-        return IntRange(imaxAbsNeg < imin ? imaxAbsNeg : imin,
-                        SignExtendedNumber(0));
-    }
-}
-
-IntRange IntRange::unionWith(const IntRange& other) const
-{
-    return IntRange(imin < other.imin ? imin : other.imin,
-                    imax > other.imax ? imax : other.imax);
-}
-
-void IntRange::unionOrAssign(const IntRange& other, bool& union_)
-{
-    if (!union_ || imin > other.imin)
-        imin = other.imin;
-    if (!union_ || imax < other.imax)
-        imax = other.imax;
-    union_ = true;
-}
-
-void IntRange::splitBySign(IntRange& negRange, bool& hasNegRange,
-                           IntRange& nonNegRange, bool& hasNonNegRange) const
-{
-    hasNegRange = imin.negative;
-    if (hasNegRange)
-    {
-        negRange.imin = imin;
-        negRange.imax = imax.negative ? imax : SignExtendedNumber(-1, true);
-    }
-    hasNonNegRange = !imax.negative;
-    if (hasNonNegRange)
-    {
-        nonNegRange.imin = imin.negative ? SignExtendedNumber(0) : imin;
-        nonNegRange.imax = imax;
-    }
-}
-
-IntRange IntRange::operator~() const
-{
-    return IntRange(~imax, ~imin);
-}
-
-IntRange IntRange::operator-() const
-{
-    return IntRange(-imax, -imin);
-}
-
-IntRange IntRange::operator&(const IntRange& rhs) const
-{
-    // unsigned or identical sign bits
-    if ((imin.negative ^ imax.negative) != 1 && (rhs.imin.negative ^ rhs.imax.negative) != 1)
-    {
-        return IntRange(minAnd(*this, rhs), maxAnd(*this, rhs));
-    }
-
-    IntRange l = IntRange(*this);
-    IntRange r = IntRange(rhs);
-
-    // both intervals span [-1,0]
-    if ((l.imin.negative ^ l.imax.negative) == 1 && (r.imin.negative ^ r.imax.negative) == 1)
-    {
-        // cannot be larger than either l.max or r.max, set the other one to -1
-        SignExtendedNumber max = l.imax.value > r.imax.value ? l.imax : r.imax;
-
-        // only negative numbers for minimum
-        l.imax.value = -1;
-        l.imax.negative = true;
-        r.imax.value = -1;
-        r.imax.negative = true;
-
-        return IntRange(minAnd(l, r), max);
-    }
-    else
-    {
-        // only one interval spans [-1,0]
-        if ((l.imin.negative ^ l.imax.negative) == 1)
-        {
-            swap(l, r); // r spans [-1,0]
-        }
-
-        SignExtendedNumber minAndNeg = minAnd(l, IntRange(r.imin, SignExtendedNumber(-1)));
-        SignExtendedNumber minAndPos = minAnd(l, IntRange(SignExtendedNumber(0), r.imax));
-        SignExtendedNumber maxAndNeg = maxAnd(l, IntRange(r.imin, SignExtendedNumber(-1)));
-        SignExtendedNumber maxAndPos = maxAnd(l, IntRange(SignExtendedNumber(0), r.imax));
-
-        SignExtendedNumber min = minAndNeg < minAndPos ? minAndNeg : minAndPos;
-        SignExtendedNumber max = maxAndNeg > maxAndPos ? maxAndNeg : maxAndPos;
-
-        return IntRange(min, max);
-    }
-}
-
-IntRange IntRange::operator|(const IntRange& rhs) const
-{
-    // unsigned or identical sign bits:
-    if ((imin.negative ^ imax.negative) == 0 && (rhs.imin.negative ^ rhs.imax.negative) == 0)
-    {
-        return IntRange(minOr(*this, rhs), maxOr(*this, rhs));
-    }
-
-    IntRange l = IntRange(*this);
-    IntRange r = IntRange(rhs);
-
-    // both intervals span [-1,0]
-    if ((l.imin.negative ^ l.imax.negative) == 1 && (r.imin.negative ^ r.imax.negative) == 1)
-    {
-        // cannot be smaller than either l.min or r.min, set the other one to 0
-        SignExtendedNumber min = l.imin.value < r.imin.value ? l.imin : r.imin;
-
-        // only negative numbers for minimum
-        l.imin.value = 0;
-        l.imin.negative = false;
-        r.imin.value = 0;
-        r.imin.negative = false;
-
-        return IntRange(min, maxOr(l, r));
-    }
-    else
-    {
-        // only one interval spans [-1,0]
-        if ((imin.negative ^ imax.negative) == 1)
-        {
-            swap(l, r); // r spans [-1,0]
-        }
-
-        SignExtendedNumber minOrNeg = minOr(l, IntRange(r.imin, SignExtendedNumber(-1)));
-        SignExtendedNumber minOrPos = minOr(l, IntRange(SignExtendedNumber(0), r.imax));
-        SignExtendedNumber maxOrNeg = maxOr(l, IntRange(r.imin, SignExtendedNumber(-1)));
-        SignExtendedNumber maxOrPos = maxOr(l, IntRange(SignExtendedNumber(0), r.imax));
-
-        SignExtendedNumber min = minOrNeg < minOrPos ? minOrNeg : minOrPos;
-        SignExtendedNumber max = maxOrNeg > maxOrPos ? maxOrNeg : maxOrPos;
-
-        return IntRange(min, max);
-    }
-}
-
-IntRange IntRange::operator^(const IntRange& rhs) const
-{
-    return (*this & (~rhs)) | (~(*this) & rhs);
-}
-
-IntRange IntRange::operator+(const IntRange& rhs) const
-{
-    return IntRange(imin + rhs.imin, imax + rhs.imax);
-}
-
-IntRange IntRange::operator-(const IntRange& rhs) const
-{
-    return IntRange(imin - rhs.imax, imax - rhs.imin);
-}
-
-IntRange IntRange::operator*(const IntRange& rhs) const
-{
-    // [a,b] * [c,d] = [min (ac, ad, bc, bd), max (ac, ad, bc, bd)]
-    SignExtendedNumber bdy[4];
-    bdy[0] = imin * rhs.imin;
-    bdy[1] = imin * rhs.imax;
-    bdy[2] = imax * rhs.imin;
-    bdy[3] = imax * rhs.imax;
-    return IntRange::fromNumbers4(bdy);
-}
-
-IntRange IntRange::operator/(const IntRange& rhs) const
-{
-    // Handle divide by 0
-    if (rhs.imax.value == 0 && rhs.imin.value == 0)
-        return widest();
-
-    IntRange r = IntRange(rhs);
-
-    // Don't treat the whole range as divide by 0 if only one end of a range is 0.
-    // Issue 15289
-    if (r.imax.value == 0)
-    {
-        r.imax.value--;
-    }
-    else if (r.imin.value == 0)
-    {
-        r.imin.value++;
-    }
-
-    if (!imin.negative && !imax.negative && !r.imin.negative && !r.imax.negative)
-    {
-        return IntRange(imin / r.imax, imax / r.imin);
-    }
-    else
-    {
-        // [a,b] / [c,d] = [min (a/c, a/d, b/c, b/d), max (a/c, a/d, b/c, b/d)]
-        SignExtendedNumber bdy[4];
-        bdy[0] = imin / r.imin;
-        bdy[1] = imin / r.imax;
-        bdy[2] = imax / r.imin;
-        bdy[3] = imax / r.imax;
-
-        return IntRange::fromNumbers4(bdy);
-    }
-}
-
-IntRange IntRange::operator%(const IntRange& rhs) const
-{
-    IntRange irNum = *this;
-    IntRange irDen = rhs.absNeg();
-
-    /*
-     due to the rules of D (C)'s % operator, we need to consider the cases
-     separately in different range of signs.
-
-         case 1. [500, 1700] % [7, 23] (numerator is always positive)
-             = [0, 22]
-         case 2. [-500, 1700] % [7, 23] (numerator can be negative)
-             = [-22, 22]
-         case 3. [-1700, -500] % [7, 23] (numerator is always negative)
-             = [-22, 0]
-
-     the number 22 is the maximum absolute value in the denomator's range. We
-     don't care about divide by zero.
-     */
-
-    irDen.imin = irDen.imin + SignExtendedNumber(1);
-    irDen.imax = -irDen.imin;
-
-    if (!irNum.imin.negative)
-    {
-        irNum.imin.value = 0;
-    }
-    else if (irNum.imin < irDen.imin)
-    {
-        irNum.imin = irDen.imin;
-    }
-
-    if (irNum.imax.negative)
-    {
-        irNum.imax.negative = false;
-        irNum.imax.value = 0;
-    }
-    else if (irNum.imax > irDen.imax)
-    {
-        irNum.imax = irDen.imax;
-    }
-
-    return irNum;
-}
-
-IntRange IntRange::operator<<(const IntRange& rhs) const
-{
-    IntRange r = IntRange(rhs);
-    if (r.imin.negative)
-    {
-        r = IntRange(SignExtendedNumber(0), SignExtendedNumber(64));
-    }
-
-    SignExtendedNumber lower = imin << (imin.negative ? r.imax : r.imin);
-    SignExtendedNumber upper = imax << (imax.negative ? r.imin : r.imax);
-
-    return IntRange(lower, upper);
-}
-
-IntRange IntRange::operator>>(const IntRange& rhs) const
-{
-    IntRange r = IntRange(rhs);
-    if (r.imin.negative)
-    {
-        r = IntRange(SignExtendedNumber(0), SignExtendedNumber(64));
-    }
-
-    SignExtendedNumber lower = imin >> (imin.negative ? r.imin : r.imax);
-    SignExtendedNumber upper = imax >> (imax.negative ? r.imax : r.imin);
-
-    return IntRange(lower, upper);
-}
-
-SignExtendedNumber IntRange::maxOr(const IntRange& lhs, const IntRange& rhs)
-{
-    uinteger_t x = 0;
-    bool sign = false;
-    uinteger_t xorvalue = lhs.imax.value ^ rhs.imax.value;
-    uinteger_t andvalue = lhs.imax.value & rhs.imax.value;
-    IntRange lhsc = IntRange(lhs);
-    IntRange rhsc = IntRange(rhs);
-
-    // Sign bit not part of the .value so we need an extra iteration
-    if (lhsc.imax.negative ^ rhsc.imax.negative)
-    {
-        sign = true;
-        if (lhsc.imax.negative)
-        {
-            if (!lhsc.imin.negative)
-            {
-                lhsc.imin.value = 0;
-            }
-            if (!rhsc.imin.negative)
-            {
-                rhsc.imin.value = 0;
-            }
-        }
-    }
-    else if (lhsc.imin.negative & rhsc.imin.negative)
-    {
-        sign = true;
-    }
-    else if (lhsc.imax.negative & rhsc.imax.negative)
-    {
-        return SignExtendedNumber(-1, false);
-    }
-
-    for (uinteger_t d = 1ULL << (8 * sizeof(uinteger_t) - 1); d; d >>= 1)
-    {
-        if (xorvalue & d)
-        {
-            x |= d;
-            if (lhsc.imax.value & d)
-            {
-                if (~lhsc.imin.value & d)
-                {
-                    lhsc.imin.value = 0;
-                }
-            }
-            else
-            {
-                if (~rhsc.imin.value & d)
-                {
-                    rhsc.imin.value = 0;
-                }
-            }
-        }
-        else if (lhsc.imin.value & rhsc.imin.value & d)
-        {
-            x |= d;
-        }
-        else if (andvalue & d)
-        {
-            x |= (d << 1) - 1;
-            break;
-        }
-    }
-
-    return SignExtendedNumber(x, sign);
-}
-
-SignExtendedNumber IntRange::minOr(const IntRange& lhs, const IntRange& rhs)
-{
-    return ~maxAnd(~lhs, ~rhs);
-}
-
-SignExtendedNumber IntRange::maxAnd(const IntRange& lhs, const IntRange& rhs)
-{
-    uinteger_t x = 0;
-    bool sign = false;
-    IntRange lhsc = IntRange(lhs);
-    IntRange rhsc = IntRange(rhs);
-
-    if (lhsc.imax.negative & rhsc.imax.negative)
-    {
-        sign = true;
-    }
-
-    for (uinteger_t d = 1ULL << (8 * sizeof(uinteger_t) - 1); d; d >>= 1)
-    {
-        if (lhsc.imax.value & rhsc.imax.value & d)
-        {
-            x |= d;
-            if (~lhsc.imin.value & d)
-            {
-                lhsc.imin.value = 0;
-            }
-            if (~rhsc.imin.value & d)
-            {
-                rhsc.imin.value = 0;
-            }
-        }
-        else if (~lhsc.imin.value & d && lhsc.imax.value & d)
-        {
-            lhsc.imax.value |= d - 1;
-        }
-        else if (~rhsc.imin.value & d && rhsc.imax.value & d)
-        {
-            rhsc.imax.value |= d - 1;
-        }
-    }
-
-    return SignExtendedNumber(x, sign);
-}
-
-SignExtendedNumber IntRange::minAnd(const IntRange& lhs, const IntRange& rhs)
-{
-    return ~maxOr(~lhs, ~rhs);
-}
-
-void IntRange::swap(IntRange& a, IntRange& b)
-{
-    IntRange aux = a;
-    a = b;
-    b = aux;
-}
-
-const IntRange& IntRange::dump(const char* funcName, Expression *e) const
-{
-    printf("[(%c)%#018llx, (%c)%#018llx] @ %s ::: %s\n",
-           imin.negative?'-':'+', (unsigned long long)imin.value,
-           imax.negative?'-':'+', (unsigned long long)imax.value,
-           funcName, e->toChars());
-    return *this;
-}