diff --git a/src/backend/cc.h b/src/backend/cc.h
index b77cc8d7222f..b527897203be 100644
--- a/src/backend/cc.h
+++ b/src/backend/cc.h
@@ -1422,9 +1422,12 @@ enum FL
         FLasm,          // (code) an ASM code
 #if TX86
         FLndp,          // saved 8087 register
+#endif
+#if TARGET_SEGMENTED
         FLfardata,      // ref to far data segment
-        FLlocalsize,    // replaced with # of locals in the stack frame
         FLcsdata,       // ref to code segment variable
+#endif
+        FLlocalsize,    // replaced with # of locals in the stack frame
         FLtlsdata,      // thread local storage
         FLbprel,        // ref to variable at fixed offset from frame pointer
         FLframehandler, // ref to C++ frame handler for NT EH
@@ -1438,7 +1441,6 @@ enum FL
         FLgotoff,       // global offset table entry inside this object file
         //FLoncedata,   // link once data
         //FLoncecode,   // link once code
-#endif
 #endif
         FLMAX
 };
diff --git a/src/backend/cdef.h b/src/backend/cdef.h
index bec39e2caf29..08d4000ee521 100644
--- a/src/backend/cdef.h
+++ b/src/backend/cdef.h
@@ -233,7 +233,7 @@ One and only one of these macros must be set by the makefile:
  * This is not quite the same as !SIXTEENBIT, as one could
  * have near/far with 32 bit code.
  */
-#define TARGET_FLAT     (MARS || !TARGET_WINDOS)
+#define TARGET_SEGMENTED     (!MARS && TARGET_WINDOS)
 
 
 #define STATEMENT_SCOPES CPP
diff --git a/src/backend/cgcod.c b/src/backend/cgcod.c
index d56103872f12..589106840c51 100644
--- a/src/backend/cgcod.c
+++ b/src/backend/cgcod.c
@@ -2213,8 +2213,10 @@ code *codelem(elem *e,regm_t *pretregs,bool constflag)
                 case TYjhandle:
 #endif
                 case TYnptr:
+#if TARGET_SEGMENTED
                 case TYsptr:
                 case TYcptr:
+#endif
                     *pretregs |= IDXREGS;
                     break;
                 case TYshort:
@@ -2227,11 +2229,11 @@ code *codelem(elem *e,regm_t *pretregs,bool constflag)
                 case TYullong:
                 case TYcent:
                 case TYucent:
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
                 case TYfptr:
                 case TYhptr:
-#endif
                 case TYvptr:
+#endif
                     *pretregs |= ALLREGS;
                     break;
             }
diff --git a/src/backend/cgcv.c b/src/backend/cgcv.c
index d582b5f7e46e..fc030f2935d4 100644
--- a/src/backend/cgcv.c
+++ b/src/backend/cgcv.c
@@ -406,9 +406,11 @@ void cv_init()
         dttab4[TYptr]  = 0x400;
         dttab4[TYnptr] = 0x400;
         dttab4[TYjhandle] = 0x400;
+#if TARGET_SEGMENTED
         dttab4[TYsptr] = 0x400;
         dttab4[TYcptr] = 0x400;
         dttab4[TYfptr] = 0x500;
+#endif
 
         if (config.flags & CFGeasyomf)
         {   cgcv.LCFDoffset  = EASY_LCFDoffset;
@@ -1546,15 +1548,17 @@ unsigned char cv4_callconv(type *t)
 
     switch (tybasic(t->Tty))
     {
-        case TYnfunc:   call = 0;       break;
+#if TARGET_SEGMENTED
         case TYffunc:   call = 1;       break;
-        case TYnpfunc:  call = 2;       break;
         case TYfpfunc:  call = 3;       break;
         case TYf16func: call = 3;       break;
-        case TYnsfunc:  call = 7;       break;
         case TYfsfunc:  call = 8;       break;
         case TYnsysfunc: call = 9;      break;
         case TYfsysfunc: call = 10;     break;
+#endif
+        case TYnfunc:   call = 0;       break;
+        case TYnpfunc:  call = 2;       break;
+        case TYnsfunc:  call = 7;       break;
         case TYifunc:   call = 1;       break;
         case TYjfunc:   call = 2;       break;
         case TYmfunc:   call = 11;      break;  // this call
@@ -1738,13 +1742,17 @@ unsigned cv4_typidx(type *t)
             if (t->Tkey)
                 goto Laarray;
 #endif
+#if TARGET_SEGMENTED
         case TYsptr:
         case TYcptr:
+#endif
         Lptr:
                         attribute |= I32 ? 10 : 0;      goto L2;
+#if TARGET_SEGMENTED
         case TYfptr:
         case TYvptr:    attribute |= I32 ? 11 : 1;      goto L2;
         case TYhptr:    attribute |= 2; goto L2;
+#endif
 
         L2:
 #if 1
@@ -1877,15 +1885,17 @@ unsigned cv4_typidx(type *t)
             typidx = cv_debtyp(d);
             break;
 
-        case TYnfunc:
+#if TARGET_SEGMENTED
         case TYffunc:
-        case TYnpfunc:
         case TYfpfunc:
         case TYf16func:
-        case TYnsfunc:
         case TYfsfunc:
         case TYnsysfunc:
         case TYfsysfunc:
+#endif
+        case TYnfunc:
+        case TYnpfunc:
+        case TYnsfunc:
         case TYmfunc:
         case TYjfunc:
         case TYifunc:
@@ -2406,10 +2416,12 @@ STATIC void cv4_func(Funcsym *s)
 #if JHANDLE
             case TYjhandle:
 #endif
-            case TYnullptr:
-            case TYnptr:
+#if TARGET_SEGMENTED
             case TYsptr:
             case TYcptr:
+#endif
+            case TYnullptr:
+            case TYnptr:
                 if (I32)
                     goto case_eax;
                 else
@@ -2427,6 +2439,7 @@ STATIC void cv4_func(Funcsym *s)
                 else
                     goto case_dxax;
 
+#if TARGET_SEGMENTED
             case TYfptr:
             case TYhptr:
                 if (I32)
@@ -2439,6 +2452,7 @@ STATIC void cv4_func(Funcsym *s)
                     goto case_edxebx;
                 else
                     goto case_dxbx;
+#endif
 
             case TYdouble:
             case TYidouble:
diff --git a/src/backend/cgelem.c b/src/backend/cgelem.c
index 13ed5d5abef3..f6a6c8c89350 100644
--- a/src/backend/cgelem.c
+++ b/src/backend/cgelem.c
@@ -133,17 +133,17 @@ int elemisone(elem *e)
             case TYllong:
             case TYullong:
             case TYnullptr:
-#if TX86
 #if JHANDLE
             case TYjhandle:
 #endif
-            case TYnptr:
+#if TARGET_SEGMENTED
             case TYsptr:
             case TYcptr:
             case TYhptr:
-#endif
             case TYfptr:
             case TYvptr:
+#endif
+            case TYnptr:
             case TYbool:
             case TYwchar_t:
             case TYdchar:
@@ -198,17 +198,17 @@ int elemisnegone(elem *e)
             case TYllong:
             case TYullong:
             case TYnullptr:
-#if TX86
+            case TYnptr:
 #if JHANDLE
             case TYjhandle:
 #endif
-            case TYnptr:
+#if TARGET_SEGMENTED
             case TYsptr:
             case TYcptr:
             case TYhptr:
-#endif
             case TYfptr:
             case TYvptr:
+#endif
             case TYbool:
             case TYwchar_t:
             case TYdchar:
@@ -1084,7 +1084,11 @@ STATIC elem * elmin(elem *e)
   /* for floating or far or huge pointers!                              */
   if (e1->Eoper == OPadd && e2->Eoper == OPadd &&
       cnst(e1->E2) && cnst(e2->E2) &&
-      (tyintegral(tym) || tybasic(tym) == TYjhandle || tybasic(tym) == TYnptr || tybasic(tym) == TYsptr ))
+      (tyintegral(tym) || tybasic(tym) == TYjhandle || tybasic(tym) == TYnptr
+#if TARGET_SEGMENTED
+       || tybasic(tym) == TYsptr
+#endif
+      ))
   {     elem *tmp;
 
         e->Eoper = OPadd;
@@ -2306,7 +2310,7 @@ STATIC elem * elind(elem *e)
           }
             break;
         case OPadd:
-#if TX86
+#if TARGET_SEGMENTED
             if (OPTIMIZER)
             {   /* Try to convert far pointer to stack pointer  */
                 elem *e12 = e1->E2;
@@ -2556,7 +2560,11 @@ CEXTERN elem * elstruct(elem *e)
                 /* We should do the analysis to see if we can use
                    something simpler than TYfptr.
                  */
+#if TARGET_SEGMENTED
                 typ = (intsize == LONGSIZE) ? TYnptr : TYfptr;
+#else
+                typ = TYnptr;
+#endif
                 e2 = el_una(OPaddr,typ,e2);
                 e2 = optelem(e2,TRUE);          /* distribute & to x and y leaves */
                 *pe2 = el_una(OPind,ty2,e2);
@@ -3401,7 +3409,7 @@ STATIC elem * elptrlptr(elem *e)
 /*********************************
  * Conversions of handle pointers to far pointers.
  */
-
+// TODO: should this function go away entirely in TARGET_FLAT mode?
 STATIC elem * elvptrfptr(elem *e)
 {   elem *e1;
     elem *e12;
@@ -3411,7 +3419,9 @@ STATIC elem * elvptrfptr(elem *e)
     if (e1->Eoper == OPadd || e1->Eoper == OPmin)
     {
         e12 = e1->E2;
+#if TARGET_SEGMENTED
         if (tybasic(e12->Ety) != TYvptr)
+#endif
         {
             /* Rewrite (vtof(e11 + e12)) to (vtof(e11) + e12)   */
             op = e->Eoper;
diff --git a/src/backend/cgen.c b/src/backend/cgen.c
index 03325045bf13..ac2ab2a80c0f 100644
--- a/src/backend/cgen.c
+++ b/src/backend/cgen.c
@@ -535,12 +535,7 @@ void addtofixlist(symbol *s,targ_size_t soffset,int seg,targ_size_t val,int flag
         ln->Lnext = *pv;
         *pv = ln;
 
-#if TARGET_FLAT
-        numbytes = tysize[TYnptr];
-        if (I64 && !(flags & CFoffset64))
-            numbytes = 4;
-        assert(!(flags & CFseg));
-#else
+#if TARGET_SEGMENTED
         switch (flags & (CFoff | CFseg))
         {
             case CFoff:         numbytes = tysize[TYnptr];      break;
@@ -548,6 +543,11 @@ void addtofixlist(symbol *s,targ_size_t soffset,int seg,targ_size_t val,int flag
             case CFoff | CFseg: numbytes = tysize[TYfptr];      break;
             default:            assert(0);
         }
+#else
+        numbytes = tysize[TYnptr];
+        if (I64 && !(flags & CFoffset64))
+            numbytes = 4;
+        assert(!(flags & CFseg));
 #endif
 #ifdef DEBUG
         assert(numbytes <= sizeof(zeros));
@@ -629,12 +629,14 @@ STATIC int outfixlist_dg(void *parameter, void *pkey, void *pvalue)
         symbol_debug(s);
         //printf("outfixlist '%s' offset %04x\n",s->Sident,ln->Loffset);
 
+#if TARGET_SEGMENTED
         if (tybasic(s->ty()) == TYf16func)
         {
             obj_far16thunk(s);          /* make it into a thunk         */
             searchfixlist(s);
         }
         else
+#endif
         {
             if (s->Sxtrnnum == 0)
             {   if (s->Sclass == SCstatic)
diff --git a/src/backend/cgobj.c b/src/backend/cgobj.c
index 2e26a4325dc4..e7926c2f3f0e 100644
--- a/src/backend/cgobj.c
+++ b/src/backend/cgobj.c
@@ -2971,8 +2971,14 @@ void objledata(int seg,targ_size_t offset,targ_size_t data,
 {   unsigned i;
     unsigned size;                      // number of bytes to output
 
+#if TARGET_SEGMENTED
+    unsigned ptrsize = tysize[TYfptr];
+#else
+    unsigned ptrsize = I64 ? 10 : 6;
+#endif
+
     if ((lcfd & LOCxx) == obj.LOCpointer)
-        size = tysize[TYfptr];
+        size = ptrsize;
     else if ((lcfd & LOCxx) == LOCbase)
         size = 2;
     else
@@ -3016,7 +3022,7 @@ L1:     ;
         TOWORD(obj.ledata->data + i,data);
     else
         TOLONG(obj.ledata->data + i,data);
-    if (size == tysize[TYfptr])         // if doing a seg:offset pair
+    if (size == ptrsize)         // if doing a seg:offset pair
         TOWORD(obj.ledata->data + i + tysize[TYnptr],0);        // segment portion
     addfixup(offset - obj.ledata->offset,lcfd,idx1,idx2);
 }
@@ -3038,19 +3044,23 @@ L1:     ;
 
 void obj_long(int seg,targ_size_t offset,unsigned long data,
         unsigned lcfd,unsigned idx1,unsigned idx2)
-{ unsigned i;
-
+{
+#if TARGET_SEGMENTED
+    unsigned sz = tysize[TYfptr];
+#else
+    unsigned sz = I64 ? 10 : 6;
+#endif
   if (
         (seg != obj.ledata->lseg ||             // or segments don't match
-         obj.ledata->i + tysize[TYfptr] > LEDATAMAX || // or it'll overflow
+         obj.ledata->i + sz > LEDATAMAX || // or it'll overflow
          offset < obj.ledata->offset || // underflow
          offset > obj.ledata->offset + obj.ledata->i
         )
      )
         ledata_new(seg,offset);
-  i = offset - obj.ledata->offset;
-  if (obj.ledata->i < i + tysize[TYfptr])
-        obj.ledata->i = i + tysize[TYfptr];
+  unsigned i = offset - obj.ledata->offset;
+  if (obj.ledata->i < i + sz)
+        obj.ledata->i = i + sz;
   TOLONG(obj.ledata->data + i,data);
   if (I32)                              // if 6 byte far pointers
         TOWORD(obj.ledata->data + i + LONGSIZE,0);              // fill out seg
@@ -3239,7 +3249,11 @@ int reftoident(int seg,targ_size_t offset,Symbol *s,targ_size_t val,
                 break;
             case CFoff | CFseg:
                 lc = obj.LOCpointer;
+#if TARGET_SEGMENTED
                 numbytes = tysize[TYfptr];
+#else
+                numbytes = I64 ? 10 : 6;
+#endif
                 break;
         }
         break;
diff --git a/src/backend/cod1.c b/src/backend/cod1.c
index 15ea38101a6e..e1b9bfac0908 100644
--- a/src/backend/cod1.c
+++ b/src/backend/cod1.c
@@ -932,17 +932,27 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
          */
         f = FLconst;
         if (e1isadd &&
-            ((e12->Eoper == OPrelconst && (f = el_fl(e12)) != FLfardata) ||
+            ((e12->Eoper == OPrelconst
+#if TARGET_SEGMENTED
+              && (f = el_fl(e12)) != FLfardata
+#endif
+             ) ||
              (e12->Eoper == OPconst && !I16 && !e1->Ecount && (!I64 || el_signx32(e12)))) &&
             !(I64 && config.flags3 & CFG3pic) &&
             e1->Ecount == e1->Ecomsub &&
+#if TARGET_SEGMENTED
             (!e1->Ecount || (~keepmsk & ALLREGS & mMSW) || (e1ty != TYfptr && e1ty != TYhptr)) &&
+#endif
             tysize(e11->Ety) == REGSIZE
            )
         {   unsigned char t;            /* component of r/m field */
             int ss;
             int ssi;
 
+#if !TARGET_SEGMENTED
+            if (e12->Eoper == OPrelconst)
+                f = el_fl(e12);
+#endif
             /*assert(datafl[f]);*/              /* what if addr of func? */
             if (!I16)
             {   /* Any register can be an index register        */
@@ -956,15 +966,6 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
                     /* Load index register with result of e11->E1       */
                     c = cdisscaledindex(e11,&idxregs,keepmsk);
                     reg = findreg(idxregs);
-#if 0 && TARGET_LINUX
-                    if (f == FLgot || f == FLgotoff)    // config.flags3 & CFG3pic
-                    {
-                        gotref = 1;
-                        pcs->Irm = modregrm(2,0,4);
-                        pcs->Isib = modregrm(ss,reg,BX);
-                    }
-                    else
-#endif
                     {
                         t = stackfl[f] ? 2 : 0;
                         pcs->Irm = modregrm(t,0,4);
@@ -1107,8 +1108,10 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
                 refparam = TRUE;
             else if (f == FLauto || f == FLtmp || f == FLbprel || f == FLfltreg)
                 reflocal = TRUE;
+#if TARGET_SEGMENTED
             else if (f == FLcsdata || tybasic(e12->Ety) == TYcptr)
                 pcs->Iflags |= CFcs;
+#endif
             else
                 assert(f != FLreg);
             pcs->IFL1 = f;
@@ -1124,6 +1127,7 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
                 idxregs = IDXREGS & ~keepmsk;
                 c = cat(c,allocreg(&idxregs,&reg,TYoffset));
 
+#if TARGET_SEGMENTED
                 /* If desired result is a far pointer, we'll have       */
                 /* to load another register with the segment of v       */
                 if (e1ty == TYfptr)
@@ -1136,6 +1140,7 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
                                                 /* MOV msreg,segreg     */
                     c = genregs(c,0x8C,segfl[f],msreg);
                 }
+#endif
                 opsave = pcs->Iop;
                 flagsave = pcs->Iflags;
                 pcs->Iop = 0x8D;
@@ -1172,7 +1177,7 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
             keepmsk & RMstore)
             idxregs |= regcon.mvar;
 
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
         switch (e1ty)
         {   case TYfptr:                        /* if far pointer       */
             case TYhptr:
@@ -1377,12 +1382,16 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
             pcs->Iflags |= CFfs;                // add FS: override
 #endif
         }
+#if TARGET_SEGMENTED
         if (s->ty() & mTYcs && LARGECODE)
             goto Lfardata;
+#endif
         goto L3;
     case FLdata:
     case FLudata:
+#if TARGET_SEGMENTED
     case FLcsdata:
+#endif
 #if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
     case FLgot:
     case FLgotoff:
@@ -1413,10 +1422,12 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
                     pcs->Irex |= REX;
             }
         }
+#if TARGET_SEGMENTED
         else if (s->ty() & mTYcs && !(fl == FLextern && LARGECODE))
         {
             pcs->Iflags |= CFcs | CFoff;
         }
+#endif
 #if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
         if (I64 && config.flags3 & CFG3pic &&
             (fl == FLtlsdata || s->ty() & mTYthread))
@@ -1450,8 +1461,9 @@ code *getlvalue(code *pcs,elem *e,regm_t keepmsk)
         break;
     }
 #endif
+#if TARGET_SEGMENTED
     case FLfardata:
-        assert(!TARGET_FLAT);
+#endif
     case FLfunc:                                /* reading from code seg */
         if (config.exe & EX_flat)
             goto L3;
@@ -1704,14 +1716,17 @@ code *fixresult(elem *e,regm_t retregs,regm_t *pretregs)
   forccs = *pretregs & mPSW;
   forregs = *pretregs & (mST01 | mST0 | mBP | ALLREGS | mES | mSTACK | XMMREGS);
   tym = tybasic(e->Ety);
-#if 0
+#if TARGET_SEGMENTED
   if (tym == TYstruct)
         // Hack to support cdstreq()
-        tym = TYfptr;
+        tym = (forregs & mMSW) ? TYfptr : TYnptr;
 #else
   if (tym == TYstruct)
+  {
         // Hack to support cdstreq()
-        tym = (forregs & mMSW) ? TYfptr : TYnptr;
+        assert(!(forregs & mMSW));
+        tym = TYnptr;
+  }
 #endif
   c = CNIL;
   sz = tysize[tym];
@@ -2287,9 +2302,12 @@ code *cdfunc(elem *e,regm_t *pretregs)
 
             // First compute numpara, the total bytes pushed on the stack
             switch (tyf)
-            {   case TYf16func:
+            {
+#if TARGET_SEGMENTED
+                case TYf16func:
                     stackalign = 2;
                     goto Ldefault;
+#endif
                 case TYmfunc:
                 case TYjfunc:
                     // last parameter goes into register
@@ -2344,9 +2362,12 @@ code *cdfunc(elem *e,regm_t *pretregs)
             }
 
             switch (tyf)
-            {   case TYf16func:
+            {
+#if TARGET_SEGMENTED
+                case TYf16func:
                     stackalign = 2;
                     goto Ldefault2;
+#endif
                 case TYmfunc:   // last parameter goes into ECX
                     preg = CX;
                     goto L1;
@@ -2695,9 +2716,11 @@ STATIC code * funccall(elem *e,unsigned numpara,unsigned numalign,regm_t *pretre
             s->Sflags &= ~GTregcand;
             s->Sflags |= SFLread;
             ce = cat(c1,cdrelconst(e1,&retregs));
+#if TARGET_SEGMENTED
             if (farfunc)
                 goto LF1;
             else
+#endif
                 goto LF2;
         }
         else
@@ -2750,7 +2773,11 @@ STATIC code * funccall(elem *e,unsigned numpara,unsigned numalign,regm_t *pretre
         assert(e1->Eoper == OPind);
         e11 = e1->E1;
         e11ty = tybasic(e11->Ety);
+#if TARGET_SEGMENTED
         assert(!I16 || (e11ty == (farfunc ? TYfptr : TYnptr)));
+#else
+        assert(!I16 || (e11ty == TYnptr));
+#endif
 
         /* if we can't use loadea()     */
         if ((EOP(e11) || e11->Eoper == OPconst) &&
@@ -2764,6 +2791,7 @@ STATIC code * funccall(elem *e,unsigned numpara,unsigned numalign,regm_t *pretre
             cgstate.stackclean--;
             /* Kill registers destroyed by an arbitrary function call */
             ce = cat(ce,getregs((mBP | ALLREGS | mES | XMMREGS) & ~fregsaved));
+#if TARGET_SEGMENTED
             if (e11ty == TYfptr)
             {   unsigned lsreg;
              LF1:
@@ -2781,6 +2809,7 @@ STATIC code * funccall(elem *e,unsigned numpara,unsigned numalign,regm_t *pretre
                         modregrm(2,3,BPRM),FLfltreg,0);
             }
             else
+#endif
             {
              LF2:
                 reg = findreg(retregs);
@@ -3072,6 +3101,7 @@ code *params(elem *e,unsigned stackalign)
                 npushes = sz / pushsize;
                 switch (e1->Eoper)
                 {   case OPind:
+#if TARGET_SEGMENTED
                         if (sz)
                         {   switch (tybasic(e1->E1->Ety))
                             {
@@ -3089,6 +3119,7 @@ code *params(elem *e,unsigned stackalign)
                                     break;
                             }
                         }
+#endif
                         c1 = codelem(e1->E1,&retregs,FALSE);
                         freenode(e1);
                         break;
@@ -3108,12 +3139,13 @@ code *params(elem *e,unsigned stackalign)
                             int fl;
 
                             fl = el_fl(e1);
+#if TARGET_SEGMENTED
                             if (fl == FLfardata)
                             {   seg = CFes;
-                                assert(!TARGET_FLAT);
                                 retregs |= mES;
                             }
                             else
+#endif
                             {
                                 s = segfl[fl];
                                 assert(s < 4);
@@ -3122,7 +3154,7 @@ code *params(elem *e,unsigned stackalign)
                                     seg = 0;
                             }
                         }
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
                         if (e1->Ety & mTYfar)
                         {   seg = CFes;
                             retregs |= mES;
@@ -3251,8 +3283,14 @@ code *params(elem *e,unsigned stackalign)
             e1 = e->E1;
             tym1 = tybasic(e1->Ety);
             /* BUG: what about pointers to functions?   */
-            segreg = (tym1 == TYnptr) ? 3<<3 :
-                     (tym1 == TYcptr) ? 1<<3 : 2<<3;
+            switch (tym1)
+            {
+                case TYnptr: segreg = 3<<3; break;
+#if TARGET_SEGMENTED
+                case TYcptr: segreg = 1<<3; break;
+#endif
+                default:     segreg = 2<<3; break;
+            }
             if (I32 && stackalign == 2)
                 c = gen1(c,0x66);               /* push a word          */
             c = gen1(c,0x06 + segreg);          /* PUSH SEGREG          */
@@ -3265,7 +3303,7 @@ code *params(elem *e,unsigned stackalign)
         }
         break;
     case OPrelconst:
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
         /* Determine if we can just push the segment register           */
         /* Test size of type rather than TYfptr because of (long)(&v)   */
         s = e->EV.sp.Vsym;
diff --git a/src/backend/cod2.c b/src/backend/cod2.c
index e2dd22823641..54a6e034109d 100644
--- a/src/backend/cod2.c
+++ b/src/backend/cod2.c
@@ -207,9 +207,14 @@ code *cdorth(elem *e,regm_t *pretregs)
   else
   {     /* If ty is a TYfptr, but both operands are long, treat the     */
         /* operation as a long.                                         */
+#if TARGET_SEGMENTED
         if ((tylong(ty1) || ty1 == TYhptr) &&
             (tylong(ty2) || ty2 == TYhptr))
             numwords++;
+#else
+        if (tylong(ty1) && tylong(ty2))
+            numwords++;
+#endif
   }
 
   // Special cases where only flags are set
@@ -460,6 +465,7 @@ code *cdorth(elem *e,regm_t *pretregs)
 #endif
         assert(tysize[ty2] == REGSIZE);
 
+#if TARGET_SEGMENTED
         /* Watch out for the case here where you are going to OP reg,EA */
         /* and both the reg and EA use ES! Prevent this by forcing      */
         /* reg into the regular registers.                              */
@@ -467,13 +473,14 @@ code *cdorth(elem *e,regm_t *pretregs)
             (e2oper == OPvar && el_fl(e2) == FLfardata)) &&
             !e2->Ecount)
         {
-                retregs = ALLREGS;
-                assert(!TARGET_FLAT);
+            retregs = ALLREGS;
         }
+#endif
 
         cl = codelem(e1,&retregs,test);
         reg = findreglsw(retregs);      /* reg is the register with the offset*/
   }
+#if TARGET_SEGMENTED
   else if (ty1 == TYhptr || ty2 == TYhptr)
   {     /* Generate code for add/subtract of huge pointers.
            No attempt is made to generate very good code.
@@ -524,6 +531,7 @@ code *cdorth(elem *e,regm_t *pretregs)
         genregs(c,0x03,mreg,lrreg);             // ADD mreg,MSREG(h)
         goto L5;
   }
+#endif
   else
   {     regm_t regm;
 
@@ -2460,7 +2468,7 @@ code *cdind(elem *e,regm_t *pretregs)
         case TYarray:
             // This case should never happen, why is it here?
             tym = TYnptr;               // don't confuse allocreg()
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
             if (*pretregs & (mES | mCX) || e->Ety & mTYfar)
                     tym = TYfptr;
 #endif
@@ -2594,11 +2602,13 @@ code *cdind(elem *e,regm_t *pretregs)
                 if (byte && reg >= 4)
                     code_orrex(ce, REX);
         }
+#if TARGET_SEGMENTED
         else if ((tym == TYfptr || tym == TYhptr) && retregs & mES)
         {
                 cs.Iop = 0xC4;          /* LES reg,[idx]                */
                 goto L2;
         }
+#endif
         else if (sz <= 2 * REGSIZE)
         {   unsigned lsreg;
 
@@ -2696,7 +2706,7 @@ code *cdind(elem *e,regm_t *pretregs)
 
 
 
-#if TARGET_FLAT
+#if !TARGET_SEGMENTED
 #define cod2_setES(ty) NULL
 #else
 /********************************
@@ -2836,6 +2846,7 @@ code *cdstrcmp( elem *e, regm_t *pretregs)
         case TYnptr:
             need_DS = FALSE;
             break;
+#if TARGET_SEGMENTED
         case TYsptr:
             if (config.wflags & WFssneds)       /* if sptr can't use DS segment */
                 segreg = SEG_SS;
@@ -2857,6 +2868,7 @@ code *cdstrcmp( elem *e, regm_t *pretregs)
             gen2(c3,0x8E,modregrm(3,SEG_DS,CX));        /* MOV DS,CX    */
             need_DS = TRUE;
             break;
+#endif
         default:
             assert(0);
     }
@@ -2945,6 +2957,7 @@ code *cdmemcmp(elem *e,regm_t *pretregs)
         case TYnptr:
             need_DS = FALSE;
             break;
+#if TARGET_SEGMENTED
         case TYsptr:
             if (config.wflags & WFssneds)       /* if sptr can't use DS segment */
                 segreg = SEG_SS;
@@ -2966,6 +2979,7 @@ code *cdmemcmp(elem *e,regm_t *pretregs)
             gen2(c3,0x8E,modregrm(3,SEG_DS,DX));        /* MOV DS,DX    */
             need_DS = TRUE;
             break;
+#endif
         default:
             assert(0);
     }
@@ -3054,6 +3068,7 @@ code *cdstrcpy(elem *e,regm_t *pretregs)
         case TYnptr:
             need_DS = FALSE;
             break;
+#if TARGET_SEGMENTED
         case TYsptr:
             if (config.wflags & WFssneds)       /* if sptr can't use DS segment */
                 segreg = SEG_SS;
@@ -3074,6 +3089,7 @@ code *cdstrcpy(elem *e,regm_t *pretregs)
             segreg = SEG_ES;
             goto L1;
             break;
+#endif
         default:
             assert(0);
     }
@@ -3172,6 +3188,7 @@ code *cdmemcpy(elem *e,regm_t *pretregs)
         case TYnptr:
             need_DS = FALSE;
             break;
+#if TARGET_SEGMENTED
         case TYsptr:
             if (config.wflags & WFssneds)       /* if sptr can't use DS segment */
                 segreg = SEG_SS;
@@ -3193,6 +3210,7 @@ code *cdmemcpy(elem *e,regm_t *pretregs)
             gen2(c3,0x8E,modregrm(3,SEG_DS,DX));        /* MOV DS,DX    */
             need_DS = TRUE;
             break;
+#endif
         default:
             assert(0);
     }
@@ -3563,6 +3581,7 @@ code *cdstreq(elem *e,regm_t *pretregs)
     {   elem *e21 = e2->E1;
 
         segreg = SEG_DS;
+#if TARGET_SEGMENTED
         switch (tybasic(e21->Ety))
         {
             case TYsptr:
@@ -3580,6 +3599,7 @@ code *cdstreq(elem *e,regm_t *pretregs)
                 need_DS = TRUE;
                 break;
         }
+#endif
         c1a = codelem(e21,&srcregs,FALSE);
         freenode(e2);
         if (segreg != SEG_DS)           /* if not DS                    */
@@ -3590,7 +3610,7 @@ code *cdstreq(elem *e,regm_t *pretregs)
     }
     else if (e2->Eoper == OPvar)
     {
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
         if (e2->EV.sp.Vsym->ty() & mTYfar) // if e2 is in a far segment
         {   srcregs |= mCX;             /* get segment also             */
             need_DS = TRUE;
@@ -3746,7 +3766,7 @@ code *cdrelconst(elem *e,regm_t *pretregs)
         case TYildouble:
         case TYcldouble:
             tym = TYnptr;               // don't confuse allocreg()
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
             if (*pretregs & (mES | mCX) || e->Ety & mTYfar)
             {
                     tym = TYfptr;
@@ -3754,11 +3774,19 @@ code *cdrelconst(elem *e,regm_t *pretregs)
 #endif
             break;
         case TYifunc:
+#if TARGET_SEGMENTED
             tym = TYfptr;
+#else
+            assert(0); // what's the right thing to do here?  TYptr?
+#endif
             break;
         default:
             if (tyfunc(tym))
-                tym = tyfarfunc(tym) ? TYfptr : TYnptr;
+                tym =
+#if TARGET_SEGMENTED
+                    tyfarfunc(tym) ? TYfptr :
+#endif
+                    TYnptr;
             break;
   }
   /*assert(tym & typtr);*/              /* don't fail on (int)&a        */
@@ -3769,7 +3797,7 @@ code *cdrelconst(elem *e,regm_t *pretregs)
         symbol *s;
 
         //elem_print(e);
-        assert(!TARGET_FLAT);
+        assert(TARGET_SEGMENTED);
 
         if (*pretregs & mES)
         {       regm_t scratch = (mAX|mBX|mDX|mDI) & ~mask[lreg];
@@ -3794,24 +3822,26 @@ code *cdrelconst(elem *e,regm_t *pretregs)
         ety = tybasic(s->ty());
         if ((tyfarfunc(ety) || ety == TYifunc) &&
             (sclass == SCextern || ClassInline(sclass) || config.wflags & WFthunk)
+#if TARGET_SEGMENTED
             || s->Sfl == FLfardata
             || (s->ty() & mTYcs && s->Sseg != cseg && (LARGECODE || s->Sclass == SCcomdat))
-//          || (s->Sfl == FLextern && s->ty() & mTYcs)
-//          || (LARGECODE && s->Sclass == SCcomdat)
+#endif
            )
         {       /* MOV mreg,seg of symbol       */
                 c1 = gencs(CNIL,0xB8 + mreg,0,FLextern,s);
                 c1->Iflags = CFseg;
                 c = cat(c,c1);
-                assert(!TARGET_FLAT);
+                assert(TARGET_SEGMENTED);
         }
         else
         {   int fl;
 
         loadreg:
             fl = s->Sfl;
+#if TARGET_SEGMENTED
             if (s->ty() & mTYcs)
                 fl = FLcsdata;
+#endif
             c = gen2(c,0x8C,            /* MOV mreg,SEG REGISTER        */
                 modregrm(3,segfl[fl],mreg));
         }
@@ -3842,9 +3872,10 @@ code *getoffset(elem *e,unsigned reg)
         cs.IEV2._EP.Vpointer = e->EV.Vpointer;
         goto L3;
 
+#if TARGET_SEGMENTED
     case FLfardata:
-        assert(!TARGET_FLAT);
         goto L4;
+#endif
 
     case FLtlsdata:
 #if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
@@ -3949,7 +3980,9 @@ code *getoffset(elem *e,unsigned reg)
     case FLgot:
     case FLgotoff:
 #endif
+#if TARGET_SEGMENTED
     case FLcsdata:
+#endif
     L4:
         cs.IEVsym2 = e->EV.sp.Vsym;
         cs.IEVoffset2 = e->EV.sp.Voffset;
@@ -4508,6 +4541,7 @@ code *cdpost(elem *e,regm_t *pretregs)
         }
         return cat4(c1,c2,c3,fixresult(e,retregs,pretregs));
   }
+#if TARGET_SEGMENTED
   else if (tyml == TYhptr)
   {
         unsigned long rvalue;
@@ -4568,6 +4602,7 @@ code *cdpost(elem *e,regm_t *pretregs)
         gen(c3,&cs);
         return cat4(c1,c2,c3,fixresult(e,retregs,pretregs));
   }
+#endif
   else if (sz == 2 * REGSIZE)
   {     unsigned sreg;
 
diff --git a/src/backend/cod3.c b/src/backend/cod3.c
index aa71f57b36e9..bf32cf9cb488 100644
--- a/src/backend/cod3.c
+++ b/src/backend/cod3.c
@@ -375,8 +375,10 @@ regm_t regmask(tym_t tym, tym_t tyf)
 #endif
         case TYnullptr:
         case TYnptr:
+#if TARGET_SEGMENTED
         case TYsptr:
         case TYcptr:
+#endif
             return mAX;
 
         case TYfloat:
@@ -390,8 +392,10 @@ regm_t regmask(tym_t tym, tym_t tyf)
         case TYdchar:
             if (!I16)
                 return mAX;
+#if TARGET_SEGMENTED
         case TYfptr:
         case TYhptr:
+#endif
             return mDX | mAX;
 
         case TYcent:
@@ -399,8 +403,10 @@ regm_t regmask(tym_t tym, tym_t tyf)
             assert(I64);
             return mDX | mAX;
 
+#if TARGET_SEGMENTED
         case TYvptr:
             return mDX | mBX;
+#endif
 
         case TYdouble:
         case TYdouble_alias:
@@ -3273,9 +3279,11 @@ void cod3_thunk(symbol *sthunk,symbol *sfunc,unsigned p,tym_t thisty,
 
     /* Skip over return address */
     thunkty = tybasic(sthunk->ty());
+#if TARGET_SEGMENTED
     if (tyfarfunc(thunkty))
         p += I32 ? 8 : tysize[TYfptr];          /* far function */
     else
+#endif
         p += tysize[TYnptr];
 
     if (!I16)
@@ -3351,7 +3359,9 @@ void cod3_thunk(symbol *sthunk,symbol *sfunc,unsigned p,tym_t thisty,
 #define FARTHIS (tysize(thisty) > REGSIZE)
 #define FARVPTR FARTHIS
 
+#if TARGET_SEGMENTED
         assert(thisty != TYvptr);               /* can't handle this case */
+#endif
 
         if (!I16)
         {
@@ -3822,8 +3832,10 @@ void assignaddrc(code *c)
                 c->IEVseg1 = DATA;
                 goto do2;
 
+#if TARGET_SEGMENTED
             case FLfardata:
             case FLcsdata:
+#endif
             case FLpseudo:
                 goto do2;
 
@@ -3976,9 +3988,11 @@ void assignaddrc(code *c)
             case FLdatseg:
                 c->IEVseg2 = DATA;
                 goto done;
+#if TARGET_SEGMENTED
             case FLcsdata:
             case FLfardata:
                 goto done;
+#endif
             case FLreg:
             case FLpseudo:
                 assert(0);
@@ -5476,12 +5490,13 @@ STATIC void do64bit(enum FL fl,union evc *uev,int flags)
             else
                     reftodatseg(cseg,offset,ad,JMPSEG,CFoff);
             break;
+#if TARGET_SEGMENTED
         case FLcsdata:
         case FLfardata:
 #if DEBUG
             symbol_print(uev->sp.Vsym);
 #endif
-            assert(!TARGET_FLAT);
+#endif
             // NOTE: In ELFOBJ all symbol refs have been tagged FLextern
             // strings and statics are treated like offsets from a
             // un-named external with is the start of .rodata or .data
@@ -5505,7 +5520,7 @@ STATIC void do64bit(enum FL fl,union evc *uev,int flags)
 
         case FLfunc:                        /* function call                */
             s = uev->sp.Vsym;               /* symbol pointer               */
-            assert(!(TARGET_FLAT && tyfarfunc(s->ty())));
+            assert(TARGET_SEGMENTED || !tyfarfunc(s->ty()));
             FLUSH();
             reftoident(cseg,offset,s,0,CFoffset64 | flags);
             break;
@@ -5550,12 +5565,6 @@ STATIC void do32bit(enum FL fl,union evc *uev,int flags, targ_size_t val)
         FLUSH();
         reftodatseg(cseg,offset,uev->_EP.Vpointer,uev->_EP.Vseg,flags);
         break;
-#if 0
-    case FLcsdata:
-        FLUSH();
-        reftocodseg(cseg,offset,uev->Vpointer);
-        break;
-#endif
     case FLframehandler:
         framehandleroffset = OFFSET();
         ad = 0;
@@ -5568,12 +5577,13 @@ STATIC void do32bit(enum FL fl,union evc *uev,int flags, targ_size_t val)
         else
                 reftodatseg(cseg,offset,ad,JMPSEG,CFoff);
         break;
+#if TARGET_SEGMENTED
     case FLcsdata:
     case FLfardata:
 #if DEBUG
         symbol_print(uev->sp.Vsym);
 #endif
-        assert(!TARGET_FLAT);
+#endif
         // NOTE: In ELFOBJ all symbol refs have been tagged FLextern
         // strings and statics are treated like offsets from a
         // un-named external with is the start of .rodata or .data
@@ -5597,7 +5607,7 @@ STATIC void do32bit(enum FL fl,union evc *uev,int flags, targ_size_t val)
 
     case FLfunc:                        /* function call                */
         s = uev->sp.Vsym;               /* symbol pointer               */
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
         if (tyfarfunc(s->ty()))
         {       /* Large code references are always absolute    */
                 FLUSH();
@@ -5613,7 +5623,7 @@ STATIC void do32bit(enum FL fl,union evc *uev,int flags, targ_size_t val)
         else
 #endif
         {
-                assert(!(TARGET_FLAT && tyfarfunc(s->ty())));
+                assert(TARGET_SEGMENTED || !tyfarfunc(s->ty()));
                 FLUSH();
                 reftoident(cseg,offset,s,val,flags);
         }
@@ -5655,12 +5665,6 @@ STATIC void do16bit(enum FL fl,union evc *uev,int flags)
         FLUSH();
         reftodatseg(cseg,offset,uev->_EP.Vpointer,uev->_EP.Vseg,flags);
         break;
-#if 0
-    case FLcsdata:
-        FLUSH();
-        reftocodseg(cseg,offset,uev->Vpointer);
-        break;
-#endif
     case FLswitch:
         FLUSH();
         ad = uev->Vswitch->Btableoffset;
@@ -5669,17 +5673,19 @@ STATIC void do16bit(enum FL fl,union evc *uev,int flags)
         else
                 reftodatseg(cseg,offset,ad,JMPSEG,CFoff);
         break;
+#if TARGET_SEGMENTED
     case FLcsdata:
     case FLfardata:
+#endif
     case FLextern:                      /* external data symbol         */
     case FLtlsdata:
-        assert(SIXTEENBIT || !TARGET_FLAT);
+        assert(SIXTEENBIT || TARGET_SEGMENTED);
         FLUSH();
         s = uev->sp.Vsym;               /* symbol pointer               */
         reftoident(cseg,offset,s,uev->sp.Voffset,flags);
         break;
     case FLfunc:                        /* function call                */
-        assert(SIXTEENBIT || !TARGET_FLAT);
+        assert(SIXTEENBIT || TARGET_SEGMENTED);
         s = uev->sp.Vsym;               /* symbol pointer               */
         if (tyfarfunc(s->ty()))
         {       /* Large code references are always absolute    */
@@ -5824,8 +5830,10 @@ void code_hydrate(code **pc)
             case FLauto:
             case FLbprel:
             case FLpara:
+#if TARGET_SEGMENTED
             case FLcsdata:
             case FLfardata:
+#endif
             case FLtlsdata:
             case FLfunc:
             case FLpseudo:
@@ -5883,8 +5891,10 @@ void code_hydrate(code **pc)
             case FLauto:
             case FLbprel:
             case FLpara:
+#if TARGET_SEGMENTED
             case FLcsdata:
             case FLfardata:
+#endif
             case FLtlsdata:
             case FLfunc:
             case FLpseudo:
@@ -5993,8 +6003,10 @@ void code_dehydrate(code **pc)
             case FLauto:
             case FLbprel:
             case FLpara:
+#if TARGET_SEGMENTED
             case FLcsdata:
             case FLfardata:
+#endif
             case FLtlsdata:
             case FLfunc:
             case FLpseudo:
@@ -6051,8 +6063,10 @@ void code_dehydrate(code **pc)
             case FLauto:
             case FLbprel:
             case FLpara:
+#if TARGET_SEGMENTED
             case FLcsdata:
             case FLfardata:
+#endif
             case FLtlsdata:
             case FLfunc:
             case FLpseudo:
diff --git a/src/backend/cod4.c b/src/backend/cod4.c
index c5041214c83f..7f9438c3467c 100644
--- a/src/backend/cod4.c
+++ b/src/backend/cod4.c
@@ -362,8 +362,10 @@ code *cdeq(elem *e,regm_t *pretregs)
              e2oper == OPrelconst &&
              !(I64 && config.flags3 & CFG3pic) &&
              ((fl = el_fl(e2)) == FLdata ||
-              fl==FLudata || fl == FLextern) &&
-             !(e2->EV.sp.Vsym->ty() & mTYcs)
+              fl==FLudata || fl == FLextern)
+#if TARGET_SEGMENTED
+              && !(e2->EV.sp.Vsym->ty() & mTYcs)
+#endif
             ) &&
             !evalinregister(e2) &&
             !e1->Ecount)        /* and no CSE headaches */
@@ -566,12 +568,15 @@ code *cdeq(elem *e,regm_t *pretregs)
         if (!retregs)
                 retregs = BYTEREGS;
   }
-  else if (retregs & mES &&
-            ((e1->Eoper == OPind &&
-                ((tymll = tybasic(e1->E1->Ety)) == TYfptr || tymll == TYhptr))
-                ||
+  else if (retregs & mES
+#if TARGET_SEGMENTED
+           && (
+             (e1->Eoper == OPind &&
+                ((tymll = tybasic(e1->E1->Ety)) == TYfptr || tymll == TYhptr)
+                ) ||
              (e1->Eoper == OPvar && e1->EV.sp.Vsym->Sfl == FLfardata)
             )
+#endif
           )
         // getlvalue() needs ES, so we can't return it
         retregs = allregs;              /* no conflicts with ES         */
@@ -632,6 +637,7 @@ code *cdeq(elem *e,regm_t *pretregs)
   c = getregs_imm(varregm);
 
   assert(!(retregs & mES && (cs.Iflags & CFSEG) == CFes));
+#if TARGET_SEGMENTED
   if ((tyml == TYfptr || tyml == TYhptr) && retregs & mES)
   {
         reg = findreglsw(retregs);
@@ -643,6 +649,7 @@ code *cdeq(elem *e,regm_t *pretregs)
         gen(c,&cs);                     /* MOV EA+2,ES                  */
   }
   else
+#endif
   {
         if (!I16)
         {
@@ -866,7 +873,11 @@ code *cdaddass(elem *e,regm_t *pretregs)
         (op == OPaddass || op == OPminass) &&
         (el_allbits(e2, 1) || el_allbits(e2, -1))
        ) ||
-       (!evalinregister(e2) && tyml != TYhptr)
+       (!evalinregister(e2)
+#if TARGET_SEGMENTED
+        && tyml != TYhptr
+#endif
+        )
       )
      )
   {
@@ -1040,8 +1051,10 @@ code *cdaddass(elem *e,regm_t *pretregs)
   else // evaluate e2 into register
   {
         retregs = (byte) ? BYTEREGS : ALLREGS;  // pick working reg
+#if TARGET_SEGMENTED
         if (tyml == TYhptr)
             retregs &= ~mCX;                    // need CX for shift count
+#endif
         cr = scodelem(e->E2,&retregs,0,TRUE);   // get rvalue
         cl = getlvalue(&cs,e1,retregs);         // get lvalue
         cl = cat(cl,modEA(&cs));
@@ -1052,6 +1065,7 @@ code *cdaddass(elem *e,regm_t *pretregs)
             if (sz == 1 && reg >= 4 && I64)
                 cs.Irex |= REX;
         }
+#if TARGET_SEGMENTED
         else if (tyml == TYhptr)
         {   unsigned mreg,lreg;
 
@@ -1077,6 +1091,7 @@ code *cdaddass(elem *e,regm_t *pretregs)
             NEWREG(cs.Irm,mreg);                        // ADD EA+2,mreg
             getlvalue_msw(&cs);
         }
+#endif
         else if (sz == 2 * REGSIZE)
         {
             cs.Irm |= modregrm(0,findreglsw(retregs),0);
@@ -1136,6 +1151,7 @@ code *cdaddass(elem *e,regm_t *pretregs)
                 ce = gen(ce,&cs);               // MOV reg,EA
             }
         }
+#if TARGET_SEGMENTED
         else if (tyfv(tyml) || tyml == TYhptr)
         {       regm_t idxregs;
 
@@ -1163,6 +1179,7 @@ code *cdaddass(elem *e,regm_t *pretregs)
                     gen(ce,&cs);                /* MOV mreg,EA+2        */
                 }
         }
+#endif
         else if (sz == 2 * REGSIZE)
         {       regm_t idx;
                 code *cm,*cl;
@@ -1878,8 +1895,10 @@ code *cdcmp(elem *e,regm_t *pretregs)
                 if (sz > REGSIZE)       // compare against DS, not DGROUP
                     goto L2;
                 break;
+#if TARGET_SEGMENTED
             case FLfardata:
                 break;
+#endif
             default:
                 goto L2;
         }
@@ -2034,7 +2053,7 @@ code *cdcmp(elem *e,regm_t *pretregs)
                     cs.Irm |= modregrm(0,7,0);
                     if (sz > REGSIZE)
                     {
-#if TARGET_FLAT
+#if !TARGET_SEGMENTED
                         if (sz == 6)
                             assert(0);
 #endif
@@ -2618,8 +2637,10 @@ code *cdshtlng(elem *e,regm_t *pretregs)
             switch (tym1)
             {
                 case TYnptr:    segreg = SEG_DS;        break;
+#if TARGET_SEGMENTED
                 case TYcptr:    segreg = SEG_CS;        break;
                 case TYsptr:    segreg = SEG_SS;        break;
+#endif
                 default:        assert(0);
             }
             ce = gen2(ce,0x8C,modregrm(3,segreg,reg));  /* MOV reg,segreg */
diff --git a/src/backend/debug.c b/src/backend/debug.c
index 739c4fe7d56a..f46390e10561 100644
--- a/src/backend/debug.c
+++ b/src/backend/debug.c
@@ -81,10 +81,12 @@ void WRTYxx(tym_t t)
 #if TX86
     if (t & mTYnear)
         dbg_printf("mTYnear|");
+#if TARGET_SEGMENTED
     if (t & mTYfar)
         dbg_printf("mTYfar|");
     if (t & mTYcs)
         dbg_printf("mTYcs|");
+#endif
 #endif
     if (t & mTYconst)
         dbg_printf("mTYconst|");
@@ -279,12 +281,16 @@ void WRFL(enum FL fl)
          "fltrg ","offst ","datsg ",
          "ctor  ","dtor  ","regsav","asm   ",
 #if TX86
-         "ndp   ","farda ","local ","csdat ","tlsdat",
+         "ndp   ",
+#endif
+#if TARGET_SEGMENTED
+         "farda ","csdat ",
+#endif
+         "local ","tlsdat",
          "bprel ","frameh","blocko","alloca",
          "stack ","dsym  ",
 #if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
          "got   ","gotoff",
-#endif
 #endif
         };
 
diff --git a/src/backend/dt.c b/src/backend/dt.c
index 0ef46fe67d82..6b67386e57f9 100644
--- a/src/backend/dt.c
+++ b/src/backend/dt.c
@@ -240,7 +240,11 @@ dt_t ** dtcoff(dt_t **pdtend,targ_size_t offset)
     while (*pdtend)
         pdtend = &((*pdtend)->DTnext);
     dt = dt_calloc(DT_coff);
+#if TARGET_SEGMENTED
     dt->Dty = TYcptr;
+#else
+    dt->Dty = TYnptr;
+#endif
     dt->DToffset = offset;
     *pdtend = dt;
     pdtend = &dt->DTnext;
diff --git a/src/backend/el.c b/src/backend/el.c
index 42d589317d19..21b9662a1d45 100644
--- a/src/backend/el.c
+++ b/src/backend/el.c
@@ -1879,7 +1879,7 @@ elem *el_convstring(elem *e)
     e->EV.ss.Vstring = NULL;
     len = e->EV.ss.Vstrlen;
 
-#if TX86
+#if TARGET_SEGMENTED
     // Handle strings that go into the code segment
     if (tybasic(e->Ety) == TYcptr ||
         (tyfv(e->Ety) && config.flags3 & CFG3strcod))
@@ -2375,8 +2375,10 @@ int el_match(elem *n1,elem *n2)
 #endif
                     case TYnullptr:
                     case TYnptr:
+#if TARGET_SEGMENTED
                     case TYsptr:
                     case TYcptr:
+#endif
                         if (NPTRSIZE == SHORTSIZE)
                             goto case_short;
                         else if (NPTRSIZE == LONGSIZE)
@@ -2394,7 +2396,7 @@ int el_match(elem *n1,elem *n2)
                         if (n1->EV.Vschar != n2->EV.Vschar)
                                 goto nomatch;
                         break;
-#if TX86
+#if TARGET_SEGMENTED
                     case TYfptr:
                     case TYhptr:
                     case TYvptr:
@@ -2650,14 +2652,15 @@ targ_llong el_tolong(elem *e)
             goto L1;
 #endif
 
-#if TX86
 #if JHANDLE
         case TYjhandle:
 #endif
-        case TYnullptr:
-        case TYnptr:
+#if TARGET_SEGMENTED
         case TYsptr:
         case TYcptr:
+#endif
+        case TYnptr:
+        case TYnullptr:
             if (NPTRSIZE == SHORTSIZE)
                 goto Ushort;
             if (NPTRSIZE == LONGSIZE)
@@ -2665,7 +2668,6 @@ targ_llong el_tolong(elem *e)
             if (NPTRSIZE == LLONGSIZE)
                 goto Ullong;
             assert(0);
-#endif
 
         case TYuint:
             if (intsize == SHORTSIZE)
@@ -2674,17 +2676,16 @@ targ_llong el_tolong(elem *e)
 
         case TYulong:
         case TYdchar:
+#if TARGET_SEGMENTED
         case TYfptr:
-#if TX86
         case TYhptr:
-#endif
         case TYvptr:
+#endif
         case TYvoid:                    /* some odd cases               */
         Ulong:
             result = e->EV.Vulong;
             break;
 
-#if TX86
         case TYint:
             if (intsize == SHORTSIZE)
                 goto Ishort;
@@ -2694,7 +2695,7 @@ targ_llong el_tolong(elem *e)
         Ilong:
             result = e->EV.Vlong;
             break;
-#endif
+
         case TYllong:
         case TYullong:
         Ullong:
@@ -3002,15 +3003,15 @@ void elem_print(elem *e)
                     case TYuchar:
                         dbg_printf("%d ",e->EV.Vuchar);
                         break;
-#if TX86
-                    case TYsptr:
 #if JHANDLE
                     case TYjhandle:
 #endif
-                    case TYnullptr:
-                    case TYnptr:
+#if TARGET_SEGMENTED
+                    case TYsptr:
                     case TYcptr:
 #endif
+                    case TYnullptr:
+                    case TYnptr:
                         if (NPTRSIZE == LONGSIZE)
                             goto L1;
                         if (NPTRSIZE == SHORTSIZE)
@@ -3036,15 +3037,13 @@ void elem_print(elem *e)
                     case TYushort:
                     case TYchar16:
                     L3:
-#if TX86
                         dbg_printf("%d ",e->EV.Vint);
                         break;
-#endif
                     case TYlong:
                     case TYulong:
                     case TYdchar:
+#if TARGET_SEGMENTED
                     case TYfptr:
-#if TX86
                     case TYvptr:
                     case TYhptr:
 #endif
@@ -3101,9 +3100,11 @@ void elem_print(elem *e)
                         dbg_printf("%gL+%gLi ", (double)e->EV.Vcldouble.re, (double)e->EV.Vcldouble.im);
                         break;
 
+#if !MARS
                     case TYident:
                         dbg_printf("'%s' ", e->ET->Tident);
                         break;
+#endif
 
                     default:
                         dbg_printf("Invalid type ");
diff --git a/src/backend/evalu8.c b/src/backend/evalu8.c
index 352e23af151d..861b0120aa56 100644
--- a/src/backend/evalu8.c
+++ b/src/backend/evalu8.c
@@ -134,24 +134,25 @@ HINT boolres(elem *e)
                 case TYbool:
                 case TYwchar_t:
                 case TYenum:
+#if !MARS
                 case TYmemptr:
+#endif
                 case TYlong:
                 case TYulong:
                 case TYdchar:
                 case TYllong:
                 case TYullong:
-#if TX86
 #if JHANDLE
                 case TYjhandle:
 #endif
-                //case TYnullptr:
-                case TYnptr:
+#if TARGET_SEGMENTED
                 case TYsptr:
                 case TYcptr:
                 case TYhptr:
-#endif
                 case TYfptr:
                 case TYvptr:
+#endif
+                case TYnptr:
                     b = el_tolong(e) != 0;
                     break;
                 case TYfloat:
diff --git a/src/backend/gloop.c b/src/backend/gloop.c
index f7da772871c5..18d3a2a64429 100644
--- a/src/backend/gloop.c
+++ b/src/backend/gloop.c
@@ -2036,14 +2036,16 @@ STATIC famlist * newfamlist(tym_t ty)
                 c.Vldouble = 1;
                 break;
 #if _MSDOS || __OS2__ || _WIN32         // if no byte ordering problems
-            case TYsptr:
-            case TYcptr:
 #if JHANDLE
             case TYjhandle:
 #endif
+#if TARGET_SEGMENTED
+            case TYsptr:
+            case TYcptr:
             case TYnptr:
             case TYfptr:
             case TYvptr:
+#endif
                 /* Convert pointers to integrals to avoid things like   */
                 /* multiplying pointers                                 */
                 ty = TYptrdiff;
@@ -2051,7 +2053,7 @@ STATIC famlist * newfamlist(tym_t ty)
             default:
                 c.Vlong = 1;
                 break;
-#if TX86
+#if TARGET_SEGMENTED
             case TYhptr:
                 ty = TYlong;
                 c.Vlong = 1;
@@ -2070,17 +2072,17 @@ STATIC famlist * newfamlist(tym_t ty)
             case TYwchar_t:             // BUG: what about 4 byte wchar_t's?
                 c.Vshort = 1;
                 break;
-#if TX86
-            case TYsptr:
-            case TYcptr:
 #if JHANDLE
             case TYjhandle:
 #endif
-            case TYnptr:
-#endif
-            case TYnullptr:
+#if TARGET_SEGMENTED
+            case TYsptr:
+            case TYcptr:
             case TYfptr:
             case TYvptr:
+#endif
+            case TYnptr:
+            case TYnullptr:
                 ty = TYint;
                 if (I64)
                     ty = TYllong;
@@ -2089,7 +2091,7 @@ STATIC famlist * newfamlist(tym_t ty)
             case TYuint:
                 c.Vint = 1;
                 break;
-#if TX86
+#if TARGET_SEGMENTED
             case TYhptr:
                 ty = TYlong;
 #endif
@@ -2110,13 +2112,13 @@ STATIC famlist * newfamlist(tym_t ty)
         c.Vldouble = 0;
         if (typtr(ty))
         {
-#if TX86
-            ty = (tybasic(ty) == TYhptr) ? TYlong : TYint;
-            if (I64)
-                ty = TYllong;
-#else
             ty = TYint;
+#if TARGET_SEGMENTED
+            if (tybasic(ty) == TYhptr)
+                ty = TYlong;
 #endif
+            if (I64)
+                ty = TYllong;
         }
         fl->c2 = el_const(ty,&c);               /* c2 = 0               */
         return fl;
@@ -2492,6 +2494,7 @@ STATIC void ivfamelems(register Iv *biv,register elem **pn)
                 n1 = n->E1;
         }
 
+#if TARGET_SEGMENTED
         // Get rid of case where we painted a far pointer to a long
         if (op == OPadd || op == OPmin)
         {   int sz;
@@ -2501,6 +2504,7 @@ STATIC void ivfamelems(register Iv *biv,register elem **pn)
                 (sz != tysize(n1->Ety) || sz != tysize(n2->Ety)))
                 return;
         }
+#endif
 
         /* Look for function of basic IV (-biv or biv op const)         */
         if (n1->Eoper == OPvar && n1->EV.sp.Vsym == biv->IVbasic)
@@ -2546,7 +2550,7 @@ STATIC void ivfamelems(register Iv *biv,register elem **pn)
                                 /* Check for subtracting two pointers */
                                 if (typtr(c2ty) && typtr(n2->Ety))
                                 {
-#if TX86
+#if TARGET_SEGMENTED
                                     if (tybasic(c2ty) == TYhptr)
                                         c2ty = TYlong;
                                     else
@@ -2885,7 +2889,7 @@ STATIC bool funcprev(Iv *biv,famlist *fl)
                     else                        /* can't subtract fptr  */
                         goto L1;
                 }
-#if TX86
+#if TARGET_SEGMENTED
                 if (tybasic(fls->c2->Ety) == TYhptr)
                     tymin = TYlong;
                 else
@@ -2893,7 +2897,7 @@ STATIC bool funcprev(Iv *biv,famlist *fl)
                     tymin = I64 ? TYllong : TYint;         /* type of (ptr - ptr) */
         }
 
-#if TX86
+#if TARGET_SEGMENTED
         /* If e1 and fls->c2 are fptrs, and are not from the same       */
         /* segment, we cannot subtract them.                            */
         if (tyfv(e1->Ety) && tyfv(fls->c2->Ety))
@@ -3214,7 +3218,7 @@ STATIC void elimbasivs(register loop *l)
                                 ne = el_bin(OPmin,ty,
                                         el_var(fl->FLtemp),
                                         C2);
-#if TX86
+#if TARGET_SEGMENTED
                                 if (tybasic(ne->E1->Ety) == TYfptr &&
                                     tybasic(ne->E2->Ety) == TYfptr)
                                 {   ne->Ety = I64 ? TYllong : TYint;
@@ -3439,15 +3443,15 @@ STATIC famlist * flcmp(famlist *f1,famlist *f2)
                         goto Lf2;
                 break;
 
-#if TX86
 #if JHANDLE
             case TYjhandle:
 #endif
-            case TYnullptr:
-            case TYnptr:        // BUG: 64 bit pointers?
+#if TARGET_SEGMENTED
             case TYsptr:
             case TYcptr:
 #endif
+            case TYnptr:        // BUG: 64 bit pointers?
+            case TYnullptr:
             case TYint:
             case TYuint:
                 if (intsize == SHORTSIZE)
@@ -3457,9 +3461,9 @@ STATIC famlist * flcmp(famlist *f1,famlist *f2)
             case TYlong:
             case TYulong:
             case TYdchar:
+#if TARGET_SEGMENTED
             case TYfptr:
             case TYvptr:
-#if TX86
             case TYhptr:
 #endif
             case_long:
diff --git a/src/backend/gother.c b/src/backend/gother.c
index 0b258cf096b4..b6f1926a1979 100644
--- a/src/backend/gother.c
+++ b/src/backend/gother.c
@@ -1205,7 +1205,7 @@ void elimass(elem *n)
             /* Don't screw up assnod[]. */
             n->Eoper = OPcomma;
             n->Ety |= n->E2->Ety & (mTYconst | mTYvolatile | mTYimmutable | mTYshared
-#if !TARGET_FLAT
+#if TARGET_SEGMENTED
                  | mTYfar
 #endif
                 );
diff --git a/src/backend/newman.c b/src/backend/newman.c
index ded98caec6e5..bd2d9505f5ac 100644
--- a/src/backend/newman.c
+++ b/src/backend/newman.c
@@ -996,14 +996,18 @@ STATIC void cpp_basic_data_type(type *t)
             CHAR('_');
             goto dochar;
 
+#if TARGET_SEGMENTED
         case TYsptr:
-        case TYnptr:
         case TYcptr:
         case TYf16ptr:
         case TYfptr:
         case TYhptr:
         case TYvptr:
+#endif
+#if !MARS
         case TYmemptr:
+#endif
+        case TYnptr:
             c = 'P' + cpp_cvidx(t->Tty);
             CHAR(c);
             cpp_pointer_type(t);
@@ -1021,6 +1025,7 @@ STATIC void cpp_basic_data_type(type *t)
         case TYvoid:
             c = 'X';
             goto dochar;
+#if !MARS
         case TYident:
             if (pstate.STintemplate)
             {
@@ -1045,6 +1050,7 @@ STATIC void cpp_basic_data_type(type *t)
             else
                 goto Ldefault;
             break;
+#endif
 
         default:
         Ldefault:
@@ -1067,6 +1073,7 @@ STATIC void cpp_function_indirect_type(type *t)
 {   int farfunc;
 
     farfunc = tyfarfunc(t->Tnext->Tty) != 0;
+#if !MARS
     if (tybasic(t->Tty) == TYmemptr)
     {
         CHAR('8' + farfunc);
@@ -1075,12 +1082,13 @@ STATIC void cpp_function_indirect_type(type *t)
         //cpp_this_type(t->Tnext,t->Ttag);      // MSC doesn't do this
     }
     else
+#endif
         CHAR('6' + farfunc);
 }
 
 STATIC void cpp_data_indirect_type(type *t)
 {   int i;
-
+#if !MARS
     if (tybasic(t->Tty) == TYmemptr)    // if pointer to member
     {
         i = cpp_cvidx(t->Tty);
@@ -1091,6 +1099,7 @@ STATIC void cpp_data_indirect_type(type *t)
         CHAR('@');
     }
     else
+#endif
         cpp_ecsu_data_indirect_type(t);
 }
 
@@ -1102,19 +1111,23 @@ STATIC void cpp_ecsu_data_indirect_type(type *t)
     if (t->Tnext)
     {   ty = t->Tnext->Tty & (mTYconst | mTYvolatile);
         switch (tybasic(t->Tty))
-        {   case TYfptr:
+        {
+#if TARGET_SEGMENTED
+            case TYfptr:
             case TYvptr:
             case TYfref:
                 ty |= mTYfar;
                 break;
+
+            case TYhptr:
+                i += 8;
+                break;
+#endif
             case TYref:
             case TYarray:
                 if (LARGEDATA && !(ty & mTYLINK))
                     ty |= mTYfar;
                 break;
-            case TYhptr:
-                i += 8;
-                break;
         }
     }
     else
@@ -1250,17 +1263,30 @@ STATIC void cpp_calling_convention(type *t)
     {
         case TYnfunc:
         case TYhfunc:
-        case TYffunc:   c = 'A';        break;
+#if TARGET_SEGMENTED
+        case TYffunc:
+#endif
+            c = 'A';        break;
+#if TARGET_SEGMENTED
         case TYf16func:
+        case TYfpfunc:
+#endif
         case TYnpfunc:
-        case TYfpfunc:  c = 'C';        break;
+            c = 'C';        break;
         case TYnsfunc:
-        case TYfsfunc:  c = 'G';        break;
+#if TARGET_SEGMENTED
+        case TYfsfunc:
+#endif
+            c = 'G';        break;
         case TYjfunc:
         case TYmfunc:
+#if TARGET_SEGMENTED
         case TYnsysfunc:
-        case TYfsysfunc: c = 'E';       break;
-        case TYifunc:   c = 'K';        break;
+        case TYfsysfunc:
+#endif
+            c = 'E';       break;
+        case TYifunc:
+            c = 'K';        break;
         default:
             assert(0);
     }
diff --git a/src/backend/optabgen.c b/src/backend/optabgen.c
index 33d27ffb484a..e7a4cc94e9f5 100644
--- a/src/backend/optabgen.c
+++ b/src/backend/optabgen.c
@@ -645,15 +645,21 @@ void fltables()
 
         static char indatafl[] =        /* is FLxxxx a data type?       */
         { FLdata,FLudata,FLreg,FLpseudo,FLauto,FLpara,FLextern,FLtmp,
-          FLcs,FLfltreg,FLallocatmp,FLdatseg,FLndp,FLfardata,FLtlsdata,FLbprel,
+          FLcs,FLfltreg,FLallocatmp,FLdatseg,FLndp,FLtlsdata,FLbprel,
           FLstack,FLregsave };
+#if TARGET_SEGMENTED
+        static char indatafl_s[] = { FLfardata, };
+#endif
 
         static char instackfl[] =       /* is FLxxxx a stack data type? */
         { FLauto,FLpara,FLtmp,FLcs,FLfltreg,FLallocatmp,FLndp,FLbprel,FLstack,FLregsave };
 
         static char inflinsymtab[] =    /* is FLxxxx in the symbol table? */
         { FLdata,FLudata,FLreg,FLpseudo,FLauto,FLpara,FLextern,FLtmp,FLfunc,
-          FLfardata,FLtlsdata,FLbprel,FLcsdata,FLstack };
+          FLtlsdata,FLbprel,FLstack };
+#if TARGET_SEGMENTED
+        static char inflinsymtab_s[] = { FLfardata,FLcsdata, };
+#endif
 
         for (i = 0; i < FLMAX; i++)
                 datafl[i] = stackfl[i] = flinsymtab[i] = 0;
@@ -667,6 +673,14 @@ void fltables()
         for (i = 0; i < sizeof(inflinsymtab); i++)
                 flinsymtab[inflinsymtab[i]] = 1;
 
+#if TARGET_SEGMENTED
+        for (i = 0; i < sizeof(indatafl_s); i++)
+                datafl[indatafl_s[i]] = 1;
+
+        for (i = 0; i < sizeof(inflinsymtab_s); i++)
+                flinsymtab[inflinsymtab_s[i]] = 1;
+#endif
+
 /* Segment registers    */
 #define ES      0
 #define CS      1
@@ -695,12 +709,14 @@ void fltables()
                 case FLblockoff: segfl[i] = CS; break;
                 case FLcs:      segfl[i] = SS;  break;
                 case FLregsave: segfl[i] = SS;  break;
-                case FLcsdata:  segfl[i] = CS;  break;
                 case FLndp:     segfl[i] = SS;  break;
                 case FLswitch:  segfl[i] = -1;  break;
                 case FLfltreg:  segfl[i] = SS;  break;
                 case FLoffset:  segfl[i] = -1;  break;
+#if TARGET_SEGMENTED
                 case FLfardata: segfl[i] = -1;  break;
+                case FLcsdata:  segfl[i] = CS;  break;
+#endif
                 case FLdatseg:  segfl[i] = DS;  break;
                 case FLctor:    segfl[i] = -1;  break;
                 case FLdtor:    segfl[i] = -1;  break;
@@ -747,8 +763,10 @@ void fltables()
 
 void dotytab()
 {
-    static tym_t _ptr[]      = { TYjhandle,TYnptr,TYsptr,TYcptr,TYf16ptr,TYfptr,TYhptr,
-                                 TYvptr };
+    static tym_t _ptr[]      = { TYjhandle,TYnptr };
+#if TARGET_SEGMENTED
+    static tym_t _ptr_nflat[]= { TYsptr,TYcptr,TYf16ptr,TYfptr,TYhptr,TYvptr };
+#endif
     static tym_t _real[]     = { TYfloat,TYdouble,TYdouble_alias,TYldouble,
                                };
     static tym_t _imaginary[] = {
@@ -761,25 +779,37 @@ void dotytab()
                                  TYwchar_t,TYushort,TYenum,TYint,TYuint,
                                  TYlong,TYulong,TYllong,TYullong,TYdchar,
                                  TYchar16, TYcent, TYucent };
-    static tym_t _ref[]      = { TYnref,TYfref,TYref };
-    static tym_t _func[]     = { TYnfunc,TYffunc,TYnpfunc,TYfpfunc,TYf16func,
-                                 TYnsfunc,TYfsfunc,TYifunc,TYmfunc,TYjfunc,
-                                 TYnsysfunc,TYfsysfunc, TYhfunc };
+    static tym_t _ref[]      = { TYnref,TYref };
+    static tym_t _func[]     = { TYnfunc,TYnpfunc,TYnsfunc,TYifunc,TYmfunc,TYjfunc,TYhfunc };
+#if TARGET_SEGMENTED
+    static tym_t _ref_nflat[] = { TYfref };
+    static tym_t _func_nflat[]= { TYffunc,TYfpfunc,TYf16func,TYfsfunc,TYnsysfunc,TYfsysfunc, };
+#endif
     static tym_t _uns[]     = { TYuchar,TYushort,TYuint,TYulong,
 #if MARS
                                 TYwchar_t,
 #endif
                                 TYdchar,TYullong,TYucent,TYchar16 };
+#if !MARS
     static tym_t _mptr[]    = { TYmemptr };
+#endif
     static tym_t _nullptr[] = { TYnullptr };
+#if TARGET_SEGMENTED
 #if OMFOBJ
     static tym_t _fv[]      = { TYfptr, TYvptr };
 #endif
 #if TARGET_WINDOS
     static tym_t _farfunc[] = { TYffunc,TYfpfunc,TYfsfunc,TYfsysfunc };
 #endif
-    static tym_t _pasfunc[] = { TYnpfunc,TYfpfunc,TYf16func,TYnsfunc,TYfsfunc,TYmfunc,TYjfunc };
-    static tym_t _revfunc[] = { TYnpfunc,TYfpfunc,TYf16func,TYjfunc };
+#endif
+    static tym_t _pasfunc[] = { TYnpfunc,TYnsfunc,TYmfunc,TYjfunc };
+#if TARGET_SEGMENTED
+    static tym_t _pasfunc_nf[] = { TYfpfunc,TYf16func,TYfsfunc, };
+#endif
+    static tym_t _revfunc[] = { TYnpfunc,TYjfunc };
+#if TARGET_SEGMENTED
+    static tym_t _revfunc_nf[] = { TYfpfunc,TYf16func, };
+#endif
     static tym_t _short[]     = { TYbool,TYchar,TYschar,TYuchar,TYshort,
                                   TYwchar_t,TYushort,TYchar16 };
     static tym_t _aggregate[] = { TYstruct,TYarray };
@@ -830,39 +860,44 @@ void dotytab()
 "complex double",       TYcdouble,      TYcdouble,  TYcdouble,  2*DOUBLESIZE,0x89,0x51,
 "complex long double",  TYcldouble,     TYcldouble, TYcldouble, 2*LNGDBLSIZE,0x89,0x52,
 
-"*",            TYptr,          TYptr,     TYptr,       2,  0x20,       0x100,
 "__near *",     TYjhandle,      TYjhandle, TYjhandle,   2,  0x20,       0x100,
 "nullptr_t",    TYnullptr,      TYnullptr, TYptr,       2,  0x20,       0x100,
 "*",            TYnptr,         TYnptr,    TYnptr,      2,  0x20,       0x100,
+"&",            TYref,          TYref,     TYref,       -1,     0,      0,
+"void",         TYvoid,         TYvoid,    TYvoid,      -1,     0x85,   3,
+"struct",       TYstruct,       TYstruct,  TYstruct,    -1,     0,      0,
+"array",        TYarray,        TYarray,   TYarray,     -1,     0x78,   0,
+"C func",       TYnfunc,        TYnfunc,   TYnfunc,     -1,     0x63,   0,
+"Pascal func",  TYnpfunc,       TYnpfunc,  TYnpfunc,    -1,     0x74,   0,
+"std func",     TYnsfunc,       TYnsfunc,  TYnsfunc,    -1,     0x63,   0,
+"*",            TYptr,          TYptr,     TYptr,       2,  0x20,       0x100,
+"member func",  TYmfunc,        TYmfunc,   TYmfunc,     -1,     0x64,   0,
+"D func",       TYjfunc,        TYjfunc,   TYjfunc,     -1,     0x74,   0,
+"C func",       TYhfunc,        TYhfunc,   TYhfunc,     -1,     0,      0,
+"__near &",     TYnref,         TYnref,    TYnref,      2,      0,      0,
+
+#if TARGET_SEGMENTED
 "__ss *",       TYsptr,         TYsptr,    TYsptr,      2,  0x20,       0x100,
 "__cs *",       TYcptr,         TYcptr,    TYcptr,      2,  0x20,       0x100,
 "__far16 *",    TYf16ptr,       TYf16ptr,  TYf16ptr,    4,  0x40,       0x200,
 "__far *",      TYfptr,         TYfptr,    TYfptr,      4,  0x40,       0x200,
 "__huge *",     TYhptr,         TYhptr,    TYhptr,      4,  0x40,       0x300,
 "__handle *",   TYvptr,         TYvptr,    TYvptr,      4,  0x40,       0x200,
-"struct",       TYstruct,       TYstruct,  TYstruct,    -1,     0,      0,
-"array",        TYarray,        TYarray,   TYarray,     -1,     0x78,   0,
-"&",            TYref,          TYref,     TYref,       -1,     0,      0,
-"__near &",     TYnref,         TYnref,    TYnref,      2,      0,      0,
-"__far &",      TYfref,         TYfref,    TYfref,      4,      0,      0,
-"C func",       TYnfunc,        TYnfunc,   TYnfunc,     -1,     0x63,   0,
-"C func",       TYhfunc,        TYhfunc,   TYhfunc,     -1,     0,      0,
 "far C func",   TYffunc,        TYffunc,   TYffunc,     -1,     0x64,   0,
-"std func",     TYnsfunc,       TYnsfunc,  TYnsfunc,    -1,     0x63,   0,
+"far Pascal func", TYfpfunc,    TYfpfunc,  TYfpfunc,    -1,     0x73,   0,
 "far std func", TYfsfunc,       TYfsfunc,  TYfsfunc,    -1,     0x64,   0,
+"_far16 Pascal func", TYf16func, TYf16func, TYf16func,  -1,     0x63,   0,
 "sys func",     TYnsysfunc,     TYnsysfunc,TYnsysfunc,  -1,     0x63,   0,
 "far sys func", TYfsysfunc,     TYfsysfunc,TYfsysfunc,  -1,     0x64,   0,
-"member func",  TYmfunc,        TYmfunc,   TYmfunc,     -1,     0x64,   0,
-"D func",        TYjfunc,       TYjfunc,   TYjfunc,     -1,     0x74,   0,
+"__far &",      TYfref,         TYfref,    TYfref,      4,      0,      0,
+#endif
+#if !MARS
 "interrupt func", TYifunc,      TYifunc,   TYifunc,     -1,     0x64,   0,
-"_far16 Pascal func", TYf16func, TYf16func, TYf16func,  -1,     0x63,   0,
-"Pascal func",  TYnpfunc,       TYnpfunc,  TYnpfunc,    -1,     0x74,   0,
-"far Pascal func",  TYfpfunc,   TYfpfunc,  TYfpfunc,    -1,     0x73,   0,
-"void",         TYvoid,         TYvoid,    TYvoid,      -1,     0x85,   3,
 "memptr",       TYmemptr,       TYmemptr,  TYmemptr,    -1,     0,      0,
 "ident",        TYident,        TYident,   TYident,     -1,     0,      0,
 "template",     TYtemplate,     TYtemplate, TYtemplate, -1,     0,      0,
 "vtshape",      TYvtshape,      TYvtshape,  TYvtshape,  -1,     0,      0,
+#endif
     };
 
     FILE *f;
@@ -891,14 +926,19 @@ void dotytab()
                      };
 
     T1(_ptr,      TYFLptr);
+#if TARGET_SEGMENTED
+    T1(_ptr_nflat,TYFLptr);
+#endif
     T1(_real,     TYFLreal);
     T1(_integral, TYFLintegral);
     T1(_imaginary,TYFLimaginary);
     T1(_complex,  TYFLcomplex);
     T1(_uns,      TYFLuns);
+#if !MARS
     T1(_mptr,     TYFLmptr);
+#endif
 
-#if OMFOBJ
+#if OMFOBJ && TARGET_SEGMENTED
     T1(_fv,       TYFLfv);
     T2(_farfunc,  TYFLfarfunc);
 #endif
@@ -909,7 +949,12 @@ void dotytab()
     T2(_ref,      TYFLref);
     T2(_func,     TYFLfunc);
     T2(_nullptr,  TYFLnullptr);
-
+#if TARGET_SEGMENTED
+    T2(_pasfunc_nf, TYFLpascal);
+    T2(_revfunc_nf, TYFLrevparam);
+    T2(_ref_nflat,  TYFLref);
+    T2(_func_nflat, TYFLfunc);
+#endif
 #undef T1
 #undef T2
 
diff --git a/src/backend/out.c b/src/backend/out.c
index 4e0f881657fd..c8aa032cab55 100644
--- a/src/backend/out.c
+++ b/src/backend/out.c
@@ -144,6 +144,7 @@ void outdata(symbol *s)
 #else
                 targ_size_t *poffset;
                 datasize += size(dt->Dty);
+#if TARGET_SEGMENTED
                 if (tybasic(dt->Dty) == TYcptr)
                 {   seg = cseg;
                     poffset = &Coffset;
@@ -157,6 +158,7 @@ void outdata(symbol *s)
                 }
 #endif
                 else
+#endif
                 {   seg = DATA;
                     poffset = &Doffset;
                 }
@@ -192,6 +194,7 @@ void outdata(symbol *s)
                      */
                     switch (ty & mTYLINK)
                     {
+#if TARGET_SEGMENTED
 #if OMFOBJ
                         case mTYfar:                    // if far data
                             seg = obj_fardata(s->Sident,datasize,&s->Soffset);
@@ -207,6 +210,7 @@ void outdata(symbol *s)
                             Coffset += datasize;
                             s->Sfl = FLcsdata;
                             break;
+#endif
                         case mTYthread:
                         {   seg_data *pseg = obj_tlsseg_bss();
 #if ELFOBJ || MACHOBJ
@@ -297,6 +301,7 @@ void outdata(symbol *s)
 #endif
         switch (ty & mTYLINK)
         {
+#if TARGET_SEGMENTED
 #if OMFOBJ
             case mTYfar:                // if far data
                 s->Sfl = FLfardata;
@@ -305,6 +310,7 @@ void outdata(symbol *s)
             case mTYcs:
                 s->Sfl = FLcsdata;
                 break;
+#endif
             case mTYnear:
             case 0:
                 s->Sfl = FLdata;        // initialized data
@@ -324,6 +330,7 @@ void outdata(symbol *s)
     {
       switch (ty & mTYLINK)
       {
+#if TARGET_SEGMENTED
 #if OMFOBJ
         case mTYfar:                    // if far data
             seg = obj_fardata(s->Sident,datasize,&s->Soffset);
@@ -337,6 +344,7 @@ void outdata(symbol *s)
             s->Soffset = Coffset;
             s->Sfl = FLcsdata;
             break;
+#endif
         case mTYthread:
         {   seg_data *pseg = obj_tlsseg();
 #if ELFOBJ || MACHOBJ
@@ -402,13 +410,15 @@ void outdata(symbol *s)
                     flags = CFoff | CFseg;
                 if (I64)
                     flags |= CFoffset64;
+#if TARGET_SEGMENTED
                 if (tybasic(dt->Dty) == TYcptr)
                     reftocodseg(seg,offset,dt->DTabytes);
-#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
                 else
+#endif
+#if TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
                     reftodatseg(seg,offset,dt->DTabytes,dt->DTseg,flags);
 #else
-                else if (dt->DTseg == DATA)
+                /*else*/ if (dt->DTseg == DATA)
                     reftodatseg(seg,offset,dt->DTabytes,DATA,flags);
                 else
                     reftofarseg(seg,offset,dt->DTabytes,dt->DTseg,flags);
@@ -488,6 +498,7 @@ void outcommon(symbol *s,targ_size_t n)
     if (n != 0)
     {
         assert(s->Sclass == SCglobal);
+#if TARGET_SEGMENTED
         if (s->ty() & mTYcs) // if store in code segment
         {
             /* COMDEFs not supported in code segment
@@ -499,7 +510,9 @@ void outcommon(symbol *s,targ_size_t n)
             out_extdef(s);
 #endif
         }
-        else if (s->ty() & mTYthread) // if store in thread local segment
+        else
+#endif
+        if (s->ty() & mTYthread) // if store in thread local segment
         {
 #if ELFOBJ
             s->Sclass = SCcomdef;
diff --git a/src/backend/rtlsym.c b/src/backend/rtlsym.c
index fa7dde56b7d5..bf2ae456448d 100644
--- a/src/backend/rtlsym.c
+++ b/src/backend/rtlsym.c
@@ -66,12 +66,12 @@ void rtlsym_init()
         }
 
 #if MARS
-        type *t = type_fake(LARGECODE ? TYffunc : TYnfunc);
+        type *t = type_fake(TYnfunc);
         t->Tmangle = mTYman_c;
         t->Tcount++;
 
         // Variadic function
-        type *tv = type_fake(LARGECODE ? TYffunc : TYnfunc);
+        type *tv = type_fake(TYnfunc);
         tv->Tmangle = mTYman_c;
         tv->Tcount++;
 #endif
diff --git a/src/backend/ty.h b/src/backend/ty.h
index 6925aec29094..64c7c1645bfa 100644
--- a/src/backend/ty.h
+++ b/src/backend/ty.h
@@ -63,51 +63,55 @@ enum TYM
     TYcdouble           = 0x19,
     TYcldouble          = 0x1A,
 
-#if TX86
     TYjhandle           = 0x1B, // Jupiter handle type, equals TYnptr except
                                 // that the debug type is different so the
                                 // debugger can distinguish them
     TYnullptr           = 0x1C,
     TYnptr              = 0x1D, // data segment relative pointer
-    TYsptr              = 0x1E, // stack segment relative pointer
-    TYcptr              = 0x1F, // code segment relative pointer
-    TYf16ptr            = 0x20, // special OS/2 far16 pointer
-    TYfptr              = 0x21, // far pointer (has segment and offset)
-    TYhptr              = 0x22, // huge pointer (has segment and offset)
-    TYvptr              = 0x23, // __handle pointer (has segment and offset)
     TYref               = 0x24, // reference to another type
     TYvoid              = 0x25,
     TYstruct            = 0x26, // watch tyaggregate()
     TYarray             = 0x27, // watch tyaggregate()
     TYnfunc             = 0x28, // near C func
-    TYffunc             = 0x29, // far  C func
     TYnpfunc            = 0x2A, // near Cpp func
-    TYfpfunc            = 0x2B, // far  Cpp func
     TYnsfunc            = 0x2C, // near stdcall func
-    TYfsfunc            = 0x2D, // far stdcall func
     TYifunc             = 0x2E, // interrupt func
-    TYmemptr            = 0x2F, // pointer to member
-    TYident             = 0x30, // type-argument
-    TYtemplate          = 0x31, // unexpanded class template
-    TYvtshape           = 0x32, // virtual function table
     TYptr               = 0x33, // generic pointer type
-    TYf16func           = 0x34, // _far16 _pascal function
-    TYnsysfunc          = 0x35, // near __syscall func
-    TYfsysfunc          = 0x36, // far __syscall func
     TYmfunc             = 0x37, // NT C++ member func
     TYjfunc             = 0x38, // LINKd D function
     TYhfunc             = 0x39, // C function with hidden parameter
     TYnref              = 0x3A, // near reference
-    TYfref              = 0x3B, // far reference
 
     TYcent              = 0x3C, // 128 bit signed integer
     TYucent             = 0x3D, // 128 bit unsigned integer
 
+#if TARGET_SEGMENTED
+    TYsptr              = 0x1E, // stack segment relative pointer
+    TYcptr              = 0x1F, // code segment relative pointer
+    TYf16ptr            = 0x20, // special OS/2 far16 pointer
+    TYfptr              = 0x21, // far pointer (has segment and offset)
+    TYhptr              = 0x22, // huge pointer (has segment and offset)
+    TYvptr              = 0x23, // __handle pointer (has segment and offset)
+    TYffunc             = 0x29, // far  C func
+    TYfpfunc            = 0x2B, // far  Cpp func
+    TYfsfunc            = 0x2D, // far stdcall func
+    TYf16func           = 0x34, // _far16 _pascal function
+    TYnsysfunc          = 0x35, // near __syscall func
+    TYfsysfunc          = 0x36, // far __syscall func
+    TYfref              = 0x3B, // far reference
+#endif
+
+#if !MARS
+    TYmemptr            = 0x2F, // pointer to member
+    TYident             = 0x30, // type-argument
+    TYtemplate          = 0x31, // unexpanded class template
+    TYvtshape           = 0x32, // virtual function table
+#endif
+
 #if MARS
 #define TYaarray        TYnptr
 #define TYdelegate      (I64 ? TYcent : TYllong)
 #define TYdarray        (I64 ? TYucent : TYullong)
-#endif
 #endif
 
     TYMAX               = 0x3E,
@@ -119,8 +123,10 @@ extern int TYptrdiff, TYsize, TYsize_t;
 
 /* Linkage type                 */
 #define mTYnear         0x100
+#if TARGET_SEGMENTED
 #define mTYfar          0x200
 #define mTYcs           0x400           // in code segment
+#endif
 #define mTYthread       0x800
 #define mTYLINK         0xF00           // all linkage bits
 
diff --git a/src/backend/type.c b/src/backend/type.c
index 2576fffe78cb..b1e59189544e 100644
--- a/src/backend/type.c
+++ b/src/backend/type.c
@@ -69,18 +69,18 @@ targ_size_t type_size(type *t)
         switch (tyb)
         {
             // in case program plays games with function pointers
+#if TARGET_SEGMENTED
             case TYffunc:
             case TYfpfunc:
-#if TX86
-            case TYnfunc:       /* in case program plays games with function pointers */
+            case TYfsfunc:
+            case TYf16func:
+#endif
             case TYhfunc:
+            case TYnfunc:       /* in case program plays games with function pointers */
             case TYnpfunc:
             case TYnsfunc:
-            case TYfsfunc:
-            case TYf16func:
             case TYifunc:
             case TYjfunc:
-#endif
 #if SCPP
                 if (ANSI)
                     synerr(EM_unknown_size,"function"); /* size of function is not known */
@@ -239,7 +239,9 @@ type *type_alloc(tym_t ty)
 {   type *t;
     static type tzero;
 
+#if TARGET_SEGMENTED
     assert(tybasic(ty) != TYtemplate);
+#endif
     if (type_list)
     {   t = type_list;
         type_list = t->Tnext;
@@ -267,6 +269,7 @@ type *type_alloc(tym_t ty)
  * Allocate a TYtemplate.
  */
 
+#if !MARS
 type *type_alloc_template(symbol *s)
 {   type *t;
 
@@ -288,6 +291,7 @@ type *type_alloc_template(symbol *s)
 #endif
     return t;
 }
+#endif
 
 /*****************************
  * Fake a type & initialize it.
@@ -332,6 +336,7 @@ type *type_allocn(tym_t ty,type *tn)
  * Allocate a TYmemptr type.
  */
 
+#if !MARS
 type *type_allocmemptr(Classsym *stag,type *tn)
 {   type *t;
 
@@ -343,6 +348,7 @@ type *type_allocmemptr(Classsym *stag,type *tn)
     //type_print(t);
     return t;
 }
+#endif
 
 /*****************************
  * Free up data type.
@@ -364,10 +370,12 @@ void type_free(type *t)
         {   param_free(&t->Tparamtypes);
             list_free(&t->Texcspec, (list_free_fp)type_free);
         }
+#if !MARS
         else if (ty == TYtemplate)
             param_free(&t->Tparamtypes);
         else if (ty == TYident)
             MEM_PH_FREE(t->Tident);
+#endif
         else if (t->Tflags & TFvla && t->Tel)
             el_free(t->Tel);
 #if SCPP
@@ -462,15 +470,22 @@ void type_init()
     }
 
     // Type of trace function
+#if TARGET_SEGMENTED
     tstrace = type_fake(I16 ? TYffunc : TYnfunc);
+#else
+    tstrace = type_fake(TYnfunc);
+#endif
     tstrace->Tmangle = mTYman_c;
     tstrace->Tcount++;
 
-#if TX86
     chartype = (config.flags3 & CFG3ju) ? tsuchar : tschar;
 
     // Type of far library function
-    tsclib =    type_fake(LARGECODE ? TYfpfunc : TYnpfunc);
+#if TARGET_SEGMENTED
+    tsclib = type_fake(LARGECODE ? TYfpfunc : TYnpfunc);
+#else
+    tsclib = type_fake(TYnpfunc);
+#endif
     tsclib->Tmangle = mTYman_c;
     tsclib->Tcount++;
 
@@ -502,18 +517,6 @@ void type_init()
             tsptr2types[i]->Tcount++;
         }
     }
-#else
-    chartype = tschar;                          /* default is signed chars */
-
-    type_list = NULL;
-    tsclib = type_fake( TYffunc );
-    tsclib->Tmangle = mTYman_c;
-    tsclib->Tcount++;
-#ifdef DEBUG
-    type_num = 0;
-    type_max = 0;
-#endif /* DEBUG */
-#endif /* TX86 */
 }
 
 /**********************************
@@ -578,21 +581,26 @@ type *type_copy(type *t)
     param_t *p;
 
     type_debug(t);
+#if !MARS
     if (tybasic(t->Tty) == TYtemplate)
     {
         tn = type_alloc_template(((typetemp_t *)t)->Tsym);
     }
     else
+#endif
         tn = type_alloc(t->Tty);
     *tn = *t;
     switch (tybasic(tn->Tty))
-    {       case TYtemplate:
+    {
+#if !MARS
+            case TYtemplate:
                 ((typetemp_t *)tn)->Tsym = ((typetemp_t *)t)->Tsym;
                 goto L1;
 
             case TYident:
                 tn->Tident = (char *)MEM_PH_STRDUP(t->Tident);
                 break;
+#endif
 
             case TYarray:
                 if (tn->Tflags & TFvla)
@@ -792,7 +800,11 @@ int type_isdependent(type *t)
         type_debug(t);
         if (t->Tflags & TFdependent)
             goto Lisdependent;
-        if (tyfunc(t->Tty) || tybasic(t->Tty) == TYtemplate)
+        if (tyfunc(t->Tty)
+#if TARGET_SEGMENTED
+                || tybasic(t->Tty) == TYtemplate
+#endif
+                )
         {
             for (param_t *p = t->Tparamtypes; p; p = p->Pnext)
             {
@@ -897,21 +909,26 @@ void type_print(type *t)
   dbg_printf(" Tcount=%d",t->Tcount);
   if (!(t->Tflags & TFsizeunknown) &&
         tybasic(t->Tty) != TYvoid &&
+#if !MARS
         tybasic(t->Tty) != TYident &&
+        tybasic(t->Tty) != TYtemplate &&
+#endif
         tybasic(t->Tty) != TYmfunc &&
-        tybasic(t->Tty) != TYarray &&
-        tybasic(t->Tty) != TYtemplate)
+        tybasic(t->Tty) != TYarray)
       dbg_printf(" Tsize=%ld",type_size(t));
   dbg_printf(" Tnext=%p",t->Tnext);
   switch (tybasic(t->Tty))
   {     case TYstruct:
+#if !MARS
         case TYmemptr:
+#endif
             dbg_printf(" Ttag=%p,'%s'",t->Ttag,t->Ttag->Sident);
             //dbg_printf(" Sfldlst=%p",t->Ttag->Sstruct->Sfldlst);
             break;
         case TYarray:
             dbg_printf(" Tdim=%ld",t->Tdim);
             break;
+#if !MARS
         case TYident:
             dbg_printf(" Tident='%s'",t->Tident);
             break;
@@ -936,6 +953,7 @@ dbg_printf("Pident=%p,Ptype=%p,Pelem=%p,Pnext=%p ",p->Pident,p->Ptype,p->Pelem,p
                 }
             }
             break;
+#endif
         default:
             if (tyfunc(t->Tty))
             {   param_t *p;
@@ -1439,7 +1457,9 @@ int typematch(type *t1,type *t2,int relax)
 
             (tybasic(t1ty) != TYstruct
                 && tybasic(t1ty) != TYenum
+#if !MARS
                 && tybasic(t1ty) != TYmemptr
+#endif
              || t1->Ttag == t2->Ttag)
                  &&
 
diff --git a/src/msc.c b/src/msc.c
index 782b5653b25e..acd926c7c4e6 100644
--- a/src/msc.c
+++ b/src/msc.c
@@ -196,12 +196,7 @@ void util_set32()
         tysize[TYuint + i] = LONGSIZE;
         tysize[TYjhandle + i] = LONGSIZE;
         tysize[TYnptr + i] = LONGSIZE;
-        tysize[TYsptr + i] = LONGSIZE;
-        tysize[TYcptr + i] = LONGSIZE;
         tysize[TYnref + i] = LONGSIZE;
-        tysize[TYfptr + i] = 6;
-        tysize[TYvptr + i] = 6;
-        tysize[TYfref + i] = 6;
     }
 
     for (int i = 0; i < 0x100; i += 0x40)
@@ -210,8 +205,6 @@ void util_set32()
         tyalignsize[TYuint + i] = LONGSIZE;
         tyalignsize[TYnullptr + i] = LONGSIZE;
         tyalignsize[TYnptr + i] = LONGSIZE;
-        tyalignsize[TYsptr + i] = LONGSIZE;
-        tyalignsize[TYcptr + i] = LONGSIZE;
         tyalignsize[TYnref + i] = LONGSIZE;
     }
 }
@@ -234,12 +227,7 @@ void util_set64()
         tysize[TYint  + i] = LONGSIZE;
         tysize[TYuint + i] = LONGSIZE;
         tysize[TYnptr + i] = 8;
-        tysize[TYsptr + i] = 8;
-        tysize[TYcptr + i] = 8;
         tysize[TYnref + i] = 8;
-        tysize[TYfptr + i] = 10;    // NOTE: There are codgen test that check
-        tysize[TYvptr + i] = 10;    // tysize[x] == tysize[TYfptr] so don't set
-        tysize[TYfref + i] = 10;    // tysize[TYfptr] to tysize[TYnptr]
         tysize[TYldouble + i] = REALSIZE;
         tysize[TYildouble + i] = REALSIZE;
         tysize[TYcldouble + i] = 2 * REALSIZE;
@@ -249,12 +237,7 @@ void util_set64()
         tyalignsize[TYuint + i] = LONGSIZE;
         tyalignsize[TYnullptr + i] = 8;
         tyalignsize[TYnptr + i] = 8;
-        tyalignsize[TYsptr + i] = 8;
-        tyalignsize[TYcptr + i] = 8;
         tyalignsize[TYnref + i] = 8;
-        tyalignsize[TYfptr + i] = 8;
-        tyalignsize[TYvptr + i] = 8;
-        tyalignsize[TYfref + i] = 8;
 #if TARGET_LINUX || TARGET_FREEBSD || TARGET_OPENBSD || TARGET_SOLARIS
         tyalignsize[TYldouble + i] = 16;
         tyalignsize[TYildouble + i] = 16;