diff --git a/src/impcnvgen.c b/src/impcnvgen.c
diff --git a/src/impcnvtab.d b/src/impcnvtab.d
@@ -0,0 +1,354 @@
+// Compiler implementation of the D programming language
+// Copyright (c) 1999-2015 by Digital Mars
+// All Rights Reserved
+// written by Walter Bright
+// http://www.digitalmars.com
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+module ddmd.impcnvtab;
+
+import ddmd.mtype;
+
+immutable ENUMTY[TMAX][TMAX] impcnvResult = impCnvTab.impcnvResultTab;
+immutable ENUMTY[TMAX][TMAX] impcnvType1 = impCnvTab.impcnvType1Tab;
+immutable ENUMTY[TMAX][TMAX] impcnvType2 = impCnvTab.impcnvType2Tab;
+
+private:
+
+struct ImpCnvTab
+{
+    ENUMTY[TMAX][TMAX] impcnvResultTab;
+    ENUMTY[TMAX][TMAX] impcnvType1Tab;
+    ENUMTY[TMAX][TMAX] impcnvType2Tab;
+}
+
+enum ImpCnvTab impCnvTab = generateImpCnvTab();
+
+ImpCnvTab generateImpCnvTab()
+{
+    ImpCnvTab impCnvTab;
+
+    // Set conversion tables
+    foreach (i; 0 .. cast(size_t)TMAX)
+    {
+        foreach (j; 0 .. cast(size_t)TMAX)
+        {
+            impCnvTab.impcnvResultTab[i][j] = Terror;
+            impCnvTab.impcnvType1Tab[i][j] = Terror;
+            impCnvTab.impcnvType2Tab[i][j] = Terror;
+        }
+    }
+
+    void X(ENUMTY t1, ENUMTY t2, ENUMTY nt1, ENUMTY nt2, ENUMTY rt)
+    {
+        impCnvTab.impcnvResultTab[t1][t2] = rt;
+        impCnvTab.impcnvType1Tab[t1][t2] = nt1;
+        impCnvTab.impcnvType2Tab[t1][t2] = nt2;
+    }
+
+    /* ======================= */
+
+    X(Tbool,Tbool,   Tbool,Tbool,    Tbool);
+    X(Tbool,Tint8,   Tint32,Tint32,  Tint32);
+    X(Tbool,Tuns8,   Tint32,Tint32,  Tint32);
+    X(Tbool,Tint16,  Tint32,Tint32,  Tint32);
+    X(Tbool,Tuns16,  Tint32,Tint32,  Tint32);
+    X(Tbool,Tint32,  Tint32,Tint32,  Tint32);
+    X(Tbool,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tbool,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tbool,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tbool,Tint128, Tint128,Tint128, Tint128);
+    X(Tbool,Tuns128, Tuns128,Tuns128, Tuns128);
+
+    X(Tbool,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tbool,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tbool,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tbool,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tbool,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tbool,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tbool,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tbool,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tbool,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tint8,Tint8,   Tint32,Tint32,  Tint32);
+    X(Tint8,Tuns8,   Tint32,Tint32,  Tint32);
+    X(Tint8,Tint16,  Tint32,Tint32,  Tint32);
+    X(Tint8,Tuns16,  Tint32,Tint32,  Tint32);
+    X(Tint8,Tint32,  Tint32,Tint32,  Tint32);
+    X(Tint8,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tint8,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tint8,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tint8,Tint128, Tint128,Tint128, Tint128);
+    X(Tint8,Tuns128, Tuns128,Tuns128, Tuns128);
+
+    X(Tint8,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tint8,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tint8,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tint8,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tint8,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tint8,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tint8,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tint8,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tint8,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tuns8,Tuns8,   Tint32,Tint32,  Tint32);
+    X(Tuns8,Tint16,  Tint32,Tint32,  Tint32);
+    X(Tuns8,Tuns16,  Tint32,Tint32,  Tint32);
+    X(Tuns8,Tint32,  Tint32,Tint32,  Tint32);
+    X(Tuns8,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tuns8,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tuns8,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tuns8,Tint128,  Tint128,Tint128,  Tint128);
+    X(Tuns8,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tuns8,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tuns8,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tuns8,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tuns8,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tuns8,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tuns8,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tuns8,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tuns8,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tuns8,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tint16,Tint16,  Tint32,Tint32,  Tint32);
+    X(Tint16,Tuns16,  Tint32,Tint32,  Tint32);
+    X(Tint16,Tint32,  Tint32,Tint32,  Tint32);
+    X(Tint16,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tint16,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tint16,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tint16,Tint128,  Tint128,Tint128,  Tint128);
+    X(Tint16,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tint16,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tint16,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tint16,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tint16,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tint16,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tint16,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tint16,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tint16,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tint16,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tuns16,Tuns16,  Tint32,Tint32,  Tint32);
+    X(Tuns16,Tint32,  Tint32,Tint32,  Tint32);
+    X(Tuns16,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tuns16,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tuns16,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tuns16,Tint128, Tint128,Tint128,  Tint128);
+    X(Tuns16,Tuns128, Tuns128,Tuns128,  Tuns128);
+
+    X(Tuns16,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tuns16,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tuns16,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tuns16,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tuns16,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tuns16,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tuns16,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tuns16,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tuns16,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tint32,Tint32,  Tint32,Tint32,  Tint32);
+    X(Tint32,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tint32,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tint32,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tint32,Tint128, Tint128,Tint128,  Tint128);
+    X(Tint32,Tuns128, Tuns128,Tuns128,  Tuns128);
+
+    X(Tint32,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tint32,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tint32,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tint32,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tint32,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tint32,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tint32,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tint32,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tint32,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tuns32,Tuns32,  Tuns32,Tuns32,  Tuns32);
+    X(Tuns32,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tuns32,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tuns32,Tint128,  Tint128,Tint128,  Tint128);
+    X(Tuns32,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tuns32,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tuns32,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tuns32,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tuns32,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tuns32,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tuns32,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tuns32,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tuns32,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tuns32,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tint64,Tint64,  Tint64,Tint64,  Tint64);
+    X(Tint64,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tint64,Tint128,  Tint128,Tint128,  Tint128);
+    X(Tint64,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tint64,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tint64,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tint64,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tint64,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tint64,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tint64,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tint64,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tint64,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tint64,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tuns64,Tuns64,  Tuns64,Tuns64,  Tuns64);
+    X(Tuns64,Tint128,  Tint128,Tint128,  Tint128);
+    X(Tuns64,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tuns64,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tuns64,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tuns64,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tuns64,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tuns64,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tuns64,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tuns64,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tuns64,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tuns64,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tint128,Tint128,  Tint128,Tint128,  Tint128);
+    X(Tint128,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tint128,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tint128,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tint128,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tint128,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tint128,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tint128,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tint128,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tint128,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tint128,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tuns128,Tuns128,  Tuns128,Tuns128,  Tuns128);
+
+    X(Tuns128,Tfloat32,     Tfloat32,Tfloat32,     Tfloat32);
+    X(Tuns128,Tfloat64,     Tfloat64,Tfloat64,     Tfloat64);
+    X(Tuns128,Tfloat80,     Tfloat80,Tfloat80,     Tfloat80);
+    X(Tuns128,Timaginary32, Tfloat32,Timaginary32, Tfloat32);
+    X(Tuns128,Timaginary64, Tfloat64,Timaginary64, Tfloat64);
+    X(Tuns128,Timaginary80, Tfloat80,Timaginary80, Tfloat80);
+    X(Tuns128,Tcomplex32,   Tfloat32,Tcomplex32,   Tcomplex32);
+    X(Tuns128,Tcomplex64,   Tfloat64,Tcomplex64,   Tcomplex64);
+    X(Tuns128,Tcomplex80,   Tfloat80,Tcomplex80,   Tcomplex80);
+
+    /* ======================= */
+
+    X(Tfloat32,Tfloat32,  Tfloat32,Tfloat32, Tfloat32);
+    X(Tfloat32,Tfloat64,  Tfloat64,Tfloat64, Tfloat64);
+    X(Tfloat32,Tfloat80,  Tfloat80,Tfloat80, Tfloat80);
+
+    X(Tfloat32,Timaginary32,  Tfloat32,Timaginary32, Tfloat32);
+    X(Tfloat32,Timaginary64,  Tfloat64,Timaginary64, Tfloat64);
+    X(Tfloat32,Timaginary80,  Tfloat80,Timaginary80, Tfloat80);
+
+    X(Tfloat32,Tcomplex32,  Tfloat32,Tcomplex32, Tcomplex32);
+    X(Tfloat32,Tcomplex64,  Tfloat64,Tcomplex64, Tcomplex64);
+    X(Tfloat32,Tcomplex80,  Tfloat80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Tfloat64,Tfloat64,  Tfloat64,Tfloat64, Tfloat64);
+    X(Tfloat64,Tfloat80,  Tfloat80,Tfloat80, Tfloat80);
+
+    X(Tfloat64,Timaginary32,  Tfloat64,Timaginary64, Tfloat64);
+    X(Tfloat64,Timaginary64,  Tfloat64,Timaginary64, Tfloat64);
+    X(Tfloat64,Timaginary80,  Tfloat80,Timaginary80, Tfloat80);
+
+    X(Tfloat64,Tcomplex32,  Tfloat64,Tcomplex64, Tcomplex64);
+    X(Tfloat64,Tcomplex64,  Tfloat64,Tcomplex64, Tcomplex64);
+    X(Tfloat64,Tcomplex80,  Tfloat80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Tfloat80,Tfloat80,  Tfloat80,Tfloat80, Tfloat80);
+
+    X(Tfloat80,Timaginary32,  Tfloat80,Timaginary80, Tfloat80);
+    X(Tfloat80,Timaginary64,  Tfloat80,Timaginary80, Tfloat80);
+    X(Tfloat80,Timaginary80,  Tfloat80,Timaginary80, Tfloat80);
+
+    X(Tfloat80,Tcomplex32,  Tfloat80,Tcomplex80, Tcomplex80);
+    X(Tfloat80,Tcomplex64,  Tfloat80,Tcomplex80, Tcomplex80);
+    X(Tfloat80,Tcomplex80,  Tfloat80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Timaginary32,Timaginary32,  Timaginary32,Timaginary32, Timaginary32);
+    X(Timaginary32,Timaginary64,  Timaginary64,Timaginary64, Timaginary64);
+    X(Timaginary32,Timaginary80,  Timaginary80,Timaginary80, Timaginary80);
+
+    X(Timaginary32,Tcomplex32,  Timaginary32,Tcomplex32, Tcomplex32);
+    X(Timaginary32,Tcomplex64,  Timaginary64,Tcomplex64, Tcomplex64);
+    X(Timaginary32,Tcomplex80,  Timaginary80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Timaginary64,Timaginary64,  Timaginary64,Timaginary64, Timaginary64);
+    X(Timaginary64,Timaginary80,  Timaginary80,Timaginary80, Timaginary80);
+
+    X(Timaginary64,Tcomplex32,  Timaginary64,Tcomplex64, Tcomplex64);
+    X(Timaginary64,Tcomplex64,  Timaginary64,Tcomplex64, Tcomplex64);
+    X(Timaginary64,Tcomplex80,  Timaginary80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Timaginary80,Timaginary80,  Timaginary80,Timaginary80, Timaginary80);
+
+    X(Timaginary80,Tcomplex32,  Timaginary80,Tcomplex80, Tcomplex80);
+    X(Timaginary80,Tcomplex64,  Timaginary80,Tcomplex80, Tcomplex80);
+    X(Timaginary80,Tcomplex80,  Timaginary80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Tcomplex32,Tcomplex32,  Tcomplex32,Tcomplex32, Tcomplex32);
+    X(Tcomplex32,Tcomplex64,  Tcomplex64,Tcomplex64, Tcomplex64);
+    X(Tcomplex32,Tcomplex80,  Tcomplex80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Tcomplex64,Tcomplex64,  Tcomplex64,Tcomplex64, Tcomplex64);
+    X(Tcomplex64,Tcomplex80,  Tcomplex80,Tcomplex80, Tcomplex80);
+
+    /* ======================= */
+
+    X(Tcomplex80,Tcomplex80,  Tcomplex80,Tcomplex80, Tcomplex80);
+
+    foreach (i; 0 .. cast(size_t)TMAX)
+    {
+        foreach (j; 0 .. cast(size_t)TMAX)
+        {
+            if (impCnvTab.impcnvResultTab[i][j] == Terror)
+            {
+                impCnvTab.impcnvResultTab[i][j] = impCnvTab.impcnvResultTab[j][i];
+                impCnvTab.impcnvType1Tab[i][j] = impCnvTab.impcnvType2Tab[j][i];
+                impCnvTab.impcnvType2Tab[i][j] = impCnvTab.impcnvType1Tab[j][i];
+            }
+        }
+    }
+
+    return impCnvTab;
+}
diff --git a/src/posix.mak b/src/posix.mak
@@ -233,7 +233,7 @@ endif
 SRC = win32.mak posix.mak osmodel.mak aggregate.h aliasthis.h arraytypes.h	\
 	attrib.h complex_t.h cond.h ctfe.h ctfe.h declaration.h dsymbol.h	\
 	enum.h errors.h expression.h globals.h hdrgen.h identifier.h idgen.d	\
-	impcnvgen.c import.h init.h intrange.h json.h lexer.h lib.h macro.h	\
+	import.h init.h intrange.h json.h lexer.h lib.h macro.h	\
 	mars.h module.h mtype.h nspace.h objc.h parse.h scanmscoff.c scanomf.c	\
 	scope.h statement.h staticassert.h target.h template.h tokens.h utf.h	\
 	version.h visitor.h libomf.d scanomf.d $(DMD_SRCS)
@@ -297,8 +297,8 @@ dmd: $(DMD_SRCS) $(ROOT_SRCS) newdelete.o glue.a backend.a verstr.h
 endif
 
 clean:
-	rm -f $(GLUE_OBJS) $(BACK_OBJS) dmd optab.o id.o impcnvgen		\
-		$(impcnvtab_output) idgen $(idgen_output) optabgen		\
+	rm -f $(GLUE_OBJS) $(BACK_OBJS) dmd optab.o id.o \
+		idgen $(idgen_output) optabgen		\
 		$(optabgen_output) verstr.h core *.cov *.deps *.gcda *.gcno *.a
 	@[ ! -d ${PGO_DIR} ] || echo You should issue manually: rm -rf ${PGO_DIR}
 
@@ -340,22 +340,13 @@ $(optabgen_output) : optabgen
 
 ######## idgen generates some source
 
-idgen_output = id.h id.c id.d
+idgen_output = id.h id.d
 $(idgen_output) : idgen
 
 idgen: idgen.d
 	CC=$(HOST_CC) $(HOST_DMD_RUN) idgen.d
 	./idgen
 
-######### impcnvgen generates some source
-
-impcnvtab_output = impcnvtab.c impcnvtab.d
-$(impcnvtab_output) : impcnvgen
-
-impcnvgen : mtype.h impcnvgen.c
-	$(CC) $(CFLAGS) -I$(ROOT) impcnvgen.c -o impcnvgen
-	./impcnvgen
-
 #########
 
 # Create (or update) the verstr.h file.
@@ -377,7 +368,7 @@ $(shell test \"$(VERSION)\" != "`cat verstr.h 2> /dev/null`" \
 
 #########
 
-$(GLUE_OBJS) : $(idgen_output) $(impcnvgen_output)
+$(GLUE_OBJS) : $(idgen_output)
 $(BACK_OBJS) : $(optabgen_output)
 
 

diff --git a/src/win32.mak b/src/win32.mak
@@ -180,7 +180,7 @@ ROOT_SRCS=$(ROOT)/aav.d $(ROOT)/array.d $(ROOT)/file.d $(ROOT)/filename.d	\
 SRCS = win32.mak posix.mak osmodel.mak aggregate.h aliasthis.h arraytypes.h	\
 	attrib.h complex_t.h cond.h ctfe.h ctfe.h declaration.h dsymbol.h	\
 	enum.h errors.h expression.h globals.h hdrgen.h identifier.h idgen.d	\
-	impcnvgen.c import.h init.h intrange.h json.h lexer.h lib.h macro.h	\
+	import.h init.h intrange.h json.h lexer.h lib.h macro.h	\
 	mars.h module.h mtype.h nspace.h objc.h parse.h scanmscoff.c scanomf.c	\
 	scope.h statement.h staticassert.h target.h template.h tokens.h utf.h	\
 	version.h visitor.h $(DMD_SRCS)
@@ -283,9 +283,9 @@ clean:
 	$(DEL) *.obj *.lib *.map
 	$(DEL) msgs.h msgs.c
 	$(DEL) elxxx.c cdxxx.c optab.c debtab.c fltables.c tytab.c
-	$(DEL) id.h id.c id.d
+	$(DEL) id.h id.d
 	$(DEL) verstr.h
-	$(DEL) impcnvtab.c impcnvtab.d impcnvgen.exe optabgen.exe
+	$(DEL) optabgen.exe
 
 install: detab install-copy
 
@@ -358,11 +358,7 @@ elxxx.c cdxxx.c optab.c debtab.c fltables.c tytab.c : \
 	$(CC) -cpp -ooptabgen.exe $C\optabgen -DMARS -DDM_TARGET_CPU_X86=1 -I$(TK)
 	.\optabgen.exe
 
-impcnvtab.c impcnvtab.d : impcnvgen.c
-	$(CC) -I$(ROOT) -cpp -DDM_TARGET_CPU_X86=1 impcnvgen
-	.\impcnvgen.exe
-
-id.h id.c id.d : idgen.d
+id.h id.d : idgen.d
 	$(HOST_DC) -run idgen
 
 verstr.h : ..\VERSION
@@ -377,10 +373,6 @@ verstr.h : ..\VERSION
 .asm.obj:
 	$(CC) -c $(CFLAGS) $*
 
-# Generated source
-impcnvtab.obj : mtype.h impcnvtab.c
-	$(CC) -c -I$(ROOT) -cpp impcnvtab
-
 iasm.obj : $(CH) $(TOTALH) $C\iasm.h iasm.c
 	$(CC) -c $(MFLAGS) -I$(ROOT) -Ae iasm