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, 411 insertions, 0 deletions

diff --git a/gcc/d/dmd/root/stringtable.d b/gcc/d/dmd/root/stringtable.d
new file mode 100644
index 0000000..42b26e2
--- /dev/null
+++ b/gcc/d/dmd/root/stringtable.d
@@ -0,0 +1,411 @@
+/**
+ * A specialized associative array with string keys stored in a variable length structure.
+ *
+ * Copyright: Copyright (C) 1999-2021 by The D Language Foundation, All Rights Reserved
+ * Authors:   Walter Bright, http://www.digitalmars.com
+ * License:   $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
+ * Source:    $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/root/stringtable.d, root/_stringtable.d)
+ * Documentation:  https://dlang.org/phobos/dmd_root_stringtable.html
+ * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/root/stringtable.d
+ */
+
+module dmd.root.stringtable;
+
+import core.stdc.string;
+import dmd.root.rmem, dmd.root.hash;
+
+private enum POOL_BITS = 12;
+private enum POOL_SIZE = (1U << POOL_BITS);
+
+/*
+Returns the smallest integer power of 2 larger than val.
+if val > 2^^63 on 64-bit targets or val > 2^^31 on 32-bit targets it enters an
+endless loop because of overflow.
+*/
+private size_t nextpow2(size_t val) @nogc nothrow pure @safe
+{
+    size_t res = 1;
+    while (res < val)
+        res <<= 1;
+    return res;
+}
+
+unittest
+{
+    assert(nextpow2(0) == 1);
+    assert(nextpow2(0xFFFF) == (1 << 16));
+    assert(nextpow2(size_t.max / 2) == size_t.max / 2 + 1);
+    // note: nextpow2((1UL << 63) + 1) results in an endless loop
+}
+
+private enum loadFactorNumerator = 8;
+private enum loadFactorDenominator = 10;        // for a load factor of 0.8
+
+private struct StringEntry
+{
+    uint hash;
+    uint vptr;
+}
+
+/********************************
+ * StringValue is a variable-length structure. It has neither proper c'tors nor a
+ * factory method because the only thing which should be creating these is StringTable.
+ * The string characters are stored in memory immediately after the StringValue struct.
+ */
+struct StringValue(T)
+{
+    T value; //T is/should typically be a pointer or a slice
+    private size_t length;
+    /+
+    char[length] chars;  // the string characters are stored here
+     +/
+
+    char* lstring() @nogc nothrow pure return
+    {
+        return cast(char*)(&this + 1);
+    }
+
+    size_t len() const @nogc nothrow pure @safe
+    {
+        return length;
+    }
+
+    const(char)* toDchars() const @nogc nothrow pure return
+    {
+        return cast(const(char)*)(&this + 1);
+    }
+
+    /// Returns: The content of this entry as a D slice
+    const(char)[] toString() const @nogc nothrow pure
+    {
+        return (cast(inout(char)*)(&this + 1))[0 .. length];
+    }
+}
+
+struct StringTable(T)
+{
+private:
+    StringEntry[] table;
+    ubyte*[] pools;
+    size_t nfill;
+    size_t count;
+    size_t countTrigger;   // amount which will trigger growing the table
+
+public:
+    void _init(size_t size = 0) nothrow pure
+    {
+        size = nextpow2((size * loadFactorDenominator) / loadFactorNumerator);
+        if (size < 32)
+            size = 32;
+        table = (cast(StringEntry*)mem.xcalloc(size, (table[0]).sizeof))[0 .. size];
+        countTrigger = (table.length * loadFactorNumerator) / loadFactorDenominator;
+        pools = null;
+        nfill = 0;
+        count = 0;
+    }
+
+    void reset(size_t size = 0) nothrow pure
+    {
+        freeMem();
+        _init(size);
+    }
+
+    ~this() nothrow pure
+    {
+        freeMem();
+    }
+
+    /**
+    Looks up the given string in the string table and returns its associated
+    value.
+
+    Params:
+     s = the string to look up
+     length = the length of $(D_PARAM s)
+     str = the string to look up
+
+    Returns: the string's associated value, or `null` if the string doesn't
+     exist in the string table
+    */
+    inout(StringValue!T)* lookup(scope const(char)[] str) inout @nogc nothrow pure
+    {
+        const(size_t) hash = calcHash(str);
+        const(size_t) i = findSlot(hash, str);
+        // printf("lookup %.*s %p\n", cast(int)str.length, str.ptr, table[i].value ?: null);
+        return getValue(table[i].vptr);
+    }
+
+    /// ditto
+    inout(StringValue!T)* lookup(scope const(char)* s, size_t length) inout @nogc nothrow pure
+    {
+        return lookup(s[0 .. length]);
+    }
+
+    /**
+    Inserts the given string and the given associated value into the string
+    table.
+
+    Params:
+     s = the string to insert
+     length = the length of $(D_PARAM s)
+     ptrvalue = the value to associate with the inserted string
+     str = the string to insert
+     value = the value to associate with the inserted string
+
+    Returns: the newly inserted value, or `null` if the string table already
+     contains the string
+    */
+    StringValue!(T)* insert(scope const(char)[] str, T value) nothrow pure
+    {
+        const(size_t) hash = calcHash(str);
+        size_t i = findSlot(hash, str);
+        if (table[i].vptr)
+            return null; // already in table
+        if (++count > countTrigger)
+        {
+            grow();
+            i = findSlot(hash, str);
+        }
+        table[i].hash = hash;
+        table[i].vptr = allocValue(str, value);
+        // printf("insert %.*s %p\n", cast(int)str.length, str.ptr, table[i].value ?: NULL);
+        return getValue(table[i].vptr);
+    }
+
+    /// ditto
+    StringValue!(T)* insert(scope const(char)* s, size_t length, T value) nothrow pure
+    {
+        return insert(s[0 .. length], value);
+    }
+
+    StringValue!(T)* update(scope const(char)[] str) nothrow pure
+    {
+        const(size_t) hash = calcHash(str);
+        size_t i = findSlot(hash, str);
+        if (!table[i].vptr)
+        {
+            if (++count > countTrigger)
+            {
+                grow();
+                i = findSlot(hash, str);
+            }
+            table[i].hash = hash;
+            table[i].vptr = allocValue(str, T.init);
+        }
+        // printf("update %.*s %p\n", cast(int)str.length, str.ptr, table[i].value ?: NULL);
+        return getValue(table[i].vptr);
+    }
+
+    StringValue!(T)* update(scope const(char)* s, size_t length) nothrow pure
+    {
+        return update(s[0 .. length]);
+    }
+
+    /********************************
+     * Walk the contents of the string table,
+     * calling fp for each entry.
+     * Params:
+     *      fp = function to call. Returns !=0 to stop
+     * Returns:
+     *      last return value of fp call
+     */
+    int apply(int function(const(StringValue!T)*) nothrow fp) nothrow
+    {
+        foreach (const se; table)
+        {
+            if (!se.vptr)
+                continue;
+            const sv = getValue(se.vptr);
+            int result = (*fp)(sv);
+            if (result)
+                return result;
+        }
+        return 0;
+    }
+
+    /// ditto
+    extern(D) int opApply(scope int delegate(const(StringValue!T)*) nothrow dg) nothrow
+    {
+        foreach (const se; table)
+        {
+            if (!se.vptr)
+                continue;
+            const sv = getValue(se.vptr);
+            int result = dg(sv);
+            if (result)
+                return result;
+        }
+        return 0;
+    }
+
+private:
+    /// Free all memory in use by this StringTable
+    void freeMem() nothrow pure
+    {
+        foreach (pool; pools)
+            mem.xfree(pool);
+        mem.xfree(table.ptr);
+        mem.xfree(pools.ptr);
+        table = null;
+        pools = null;
+    }
+
+    // Note that a copy is made of str
+    uint allocValue(scope const(char)[] str, T value) nothrow pure
+    {
+        const(size_t) nbytes = (StringValue!T).sizeof + str.length + 1;
+        if (!pools.length || nfill + nbytes > POOL_SIZE)
+        {
+            pools = (cast(ubyte**) mem.xrealloc(pools.ptr, (pools.length + 1) * (pools[0]).sizeof))[0 .. pools.length + 1];
+            pools[$-1] = cast(ubyte*) mem.xmalloc(nbytes > POOL_SIZE ? nbytes : POOL_SIZE);
+            if (mem.isGCEnabled)
+                memset(pools[$ - 1], 0xff, POOL_SIZE); // 0xff less likely to produce GC pointer
+            nfill = 0;
+        }
+        StringValue!(T)* sv = cast(StringValue!(T)*)&pools[$ - 1][nfill];
+        sv.value = value;
+        sv.length = str.length;
+        .memcpy(sv.lstring(), str.ptr, str.length);
+        sv.lstring()[str.length] = 0;
+        const(uint) vptr = cast(uint)(pools.length << POOL_BITS | nfill);
+        nfill += nbytes + (-nbytes & 7); // align to 8 bytes
+        return vptr;
+    }
+
+    inout(StringValue!T)* getValue(uint vptr) inout @nogc nothrow pure
+    {
+        if (!vptr)
+            return null;
+        const(size_t) idx = (vptr >> POOL_BITS) - 1;
+        const(size_t) off = vptr & POOL_SIZE - 1;
+        return cast(inout(StringValue!T)*)&pools[idx][off];
+    }
+
+    size_t findSlot(hash_t hash, scope const(char)[] str) const @nogc nothrow pure
+    {
+        // quadratic probing using triangular numbers
+        // http://stackoverflow.com/questions/2348187/moving-from-linear-probing-to-quadratic-probing-hash-collisons/2349774#2349774
+        for (size_t i = hash & (table.length - 1), j = 1;; ++j)
+        {
+            const(StringValue!T)* sv;
+            auto vptr = table[i].vptr;
+            if (!vptr || table[i].hash == hash && (sv = getValue(vptr)).length == str.length && .memcmp(str.ptr, sv.toDchars(), str.length) == 0)
+                return i;
+            i = (i + j) & (table.length - 1);
+        }
+    }
+
+    void grow() nothrow pure
+    {
+        const odim = table.length;
+        auto otab = table;
+        const ndim = table.length * 2;
+        countTrigger = (ndim * loadFactorNumerator) / loadFactorDenominator;
+        table = (cast(StringEntry*)mem.xcalloc_noscan(ndim, (table[0]).sizeof))[0 .. ndim];
+        foreach (const se; otab[0 .. odim])
+        {
+            if (!se.vptr)
+                continue;
+            const sv = getValue(se.vptr);
+            table[findSlot(se.hash, sv.toString())] = se;
+        }
+        mem.xfree(otab.ptr);
+    }
+}
+
+nothrow unittest
+{
+    StringTable!(const(char)*) tab;
+    tab._init(10);
+
+    // construct two strings with the same text, but a different pointer
+    const(char)[6] fooBuffer = "foofoo";
+    const(char)[] foo = fooBuffer[0 .. 3];
+    const(char)[] fooAltPtr = fooBuffer[3 .. 6];
+
+    assert(foo.ptr != fooAltPtr.ptr);
+
+    // first insertion returns value
+    assert(tab.insert(foo, foo.ptr).value == foo.ptr);
+
+    // subsequent insertion of same string return null
+    assert(tab.insert(foo.ptr, foo.length, foo.ptr) == null);
+    assert(tab.insert(fooAltPtr, foo.ptr) == null);
+
+    const lookup = tab.lookup("foo");
+    assert(lookup.value == foo.ptr);
+    assert(lookup.len == 3);
+    assert(lookup.toString() == "foo");
+
+    assert(tab.lookup("bar") == null);
+    tab.update("bar".ptr, "bar".length);
+    assert(tab.lookup("bar").value == null);
+
+    tab.reset(0);
+    assert(tab.lookup("foo".ptr, "foo".length) == null);
+    //tab.insert("bar");
+}
+
+nothrow unittest
+{
+    StringTable!(void*) tab;
+    tab._init(100);
+
+    enum testCount = 2000;
+
+    char[2 * testCount] buf;
+
+    foreach(i; 0 .. testCount)
+    {
+        buf[i * 2 + 0] = cast(char) (i % 256);
+        buf[i * 2 + 1] = cast(char) (i / 256);
+        auto toInsert = cast(const(char)[]) buf[i * 2 .. i * 2 + 2];
+        tab.insert(toInsert, cast(void*) i);
+    }
+
+    foreach(i; 0 .. testCount)
+    {
+        auto toLookup = cast(const(char)[]) buf[i * 2 .. i * 2 + 2];
+        assert(tab.lookup(toLookup).value == cast(void*) i);
+    }
+}
+
+nothrow unittest
+{
+    StringTable!(int) tab;
+    tab._init(10);
+    tab.insert("foo",  4);
+    tab.insert("bar",  6);
+
+    static int resultFp = 0;
+    int resultDg = 0;
+    static bool returnImmediately = false;
+
+    int function(const(StringValue!int)*) nothrow applyFunc = (const(StringValue!int)* s)
+    {
+        resultFp += s.value;
+        return returnImmediately;
+    };
+
+    scope int delegate(const(StringValue!int)*) nothrow applyDeleg = (const(StringValue!int)* s)
+    {
+        resultDg += s.value;
+        return returnImmediately;
+    };
+
+    tab.apply(applyFunc);
+    tab.opApply(applyDeleg);
+
+    assert(resultDg == 10);
+    assert(resultFp == 10);
+
+    returnImmediately = true;
+
+    tab.apply(applyFunc);
+    tab.opApply(applyDeleg);
+
+    // Order of string table iteration is not specified, either foo or bar could
+    // have been visited first.
+    assert(resultDg == 14 || resultDg == 16);
+    assert(resultFp == 14 || resultFp == 16);
+}