Blame |
Last modification |
View Log
| Download
| RSS feed
| ?url?
/* code1750.c */
/*****************************************************************************/
/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only */
/* */
/* AS-Portierung */
/* */
/* Code Generator MIL-STD-1750 */
/* */
/* This generator is heavily based on the as1750 assembler written by */
/* Oliver M. Kellogg, Dornier Satellite Systems. Yes, I know, it's been */
/* floating around on my hard drive for almost two decades before I got my */
/* a** up to finally do it. But maybe someone still reads it... */
/* */
/*****************************************************************************/
#include "stdinc.h"
#include <string.h>
#include <ctype.h>
#include "bpemu.h"
#include "strutil.h"
#include "asmdef.h"
#include "asmsub.h"
#include "asmpars.h"
#include "asmitree.h"
#include "codepseudo.h"
#include "fourpseudo.h"
#include "codevars.h"
#include "headids.h"
#include "be_le.h"
#include "ieeefloat.h"
#include "errmsg.h"
#include "code1750.h"
/*-------------------------------------------------------------------------*/
typedef struct
{
const char *pName
;
Word Code
;
} tCondition
;
static CPUVar CPU1750
;
static Word AdrReg
, AdrWord
;
/*-------------------------------------------------------------------------*/
/* Utility Functions */
static void PutCode
(Word Code
)
{
WAsmCode
[CodeLen
++] = Code
;
}
static Boolean DecodeReg
(const char *pAsc
, Word
*pResult
)
{
if (toupper(*pAsc
) != 'R')
return False
;
pAsc
++;
*pResult
= 0;
while (*pAsc
)
{
if (!isdigit(*pAsc
))
return False
;
*pResult
= (*pResult
* 10) + (*pAsc
- '0');
if (*pResult
> 15)
return False
;
pAsc
++;
}
return True
;
}
static Boolean DecodeBaseReg
(const char *pAsc
, Word
*pResult
)
{
if ((toupper(*pAsc
) != 'R') && (toupper(*pAsc
) != 'B'))
return False
;
pAsc
++;
*pResult
= 0;
while (*pAsc
)
{
if (!isdigit(*pAsc
))
return False
;
*pResult
= (*pResult
* 10) + (*pAsc
- '0');
if (*pResult
> 15)
return False
;
pAsc
++;
}
if (*pResult
< 12)
return False
;
*pResult
-= 12;
return True
;
}
static Boolean DecodeArgReg
(unsigned Index
, Word
*pResult
)
{
Boolean Result
= DecodeReg
(ArgStr
[Index
].
str.
p_str, pResult
);
if (!Result
)
WrStrErrorPos
(ErrNum_InvReg
, &ArgStr
[Index
]);
return Result
;
}
static Boolean DecodeArgBaseReg
(unsigned Index
, Word
*pResult
)
{
Boolean Result
= DecodeBaseReg
(ArgStr
[Index
].
str.
p_str, pResult
);
if (!Result
)
WrStrErrorPos
(ErrNum_InvReg
, &ArgStr
[Index
]);
return Result
;
}
static Boolean DecodeAdr
(int StartIdx
, int StopIdx
)
{
Boolean OK
;
AdrWord
= EvalStrIntExpression
(&ArgStr
[StartIdx
], Int16
, &OK
);
if (!OK
)
return False
;
if (StopIdx
> StartIdx
)
{
OK
= False
;
if (!DecodeArgReg
(StartIdx
+ 1, &AdrReg
));
else if (AdrReg
== 0)
WrXErrorPos
(ErrNum_InvAddrMode
, "!R0", &ArgStr
[StartIdx
+ 1].
Pos);
else
OK
= True
;
return OK
;
}
else
AdrReg
= 0;
return OK
;
}
static Boolean DecodeCondition
(const char *pAsc
, Word
*pResult
)
{
static const tCondition Conditions
[] =
{
{ "LT", 0x1 }, /* 0001 */
{ "LZ", 0x1 }, /* 0001 */
{ "EQ", 0x2 }, /* 0010 */
{ "EZ", 0x2 }, /* 0010 */
{ "LE", 0x3 }, /* 0011 */
{ "LEZ", 0x3 }, /* 0011 */
{ "GT", 0x4 }, /* 0100 */
{ "GTZ", 0x4 }, /* 0100 */
{ "NE", 0x5 }, /* 0101 */
{ "NZ", 0x5 }, /* 0101 */
{ "GE", 0x6 }, /* 0110 */
{ "GEZ", 0x6 }, /* 0110 */
{ "ALL", 0x7 }, /* 0111 */
{ "CY", 0x8 }, /* 1000 */
{ "CLT", 0x9 }, /* 1001 */
{ "CEQ", 0xA }, /* 1010 */
{ "CEZ", 0xA }, /* 1010 */
{ "CLE", 0xB }, /* 1011 */
{ "CGT", 0xC }, /* 1100 */
{ "CNZ", 0xD }, /* 1101 */
{ "CGE", 0xE }, /* 1110 */
{ "UC", 0xF }, /* 1111 */
{ NULL
, 0x0 },
};
const tCondition
*pCond
;
for (pCond
= Conditions
; pCond
->pName
; pCond
++)
if (!as_strcasecmp
(pAsc
, pCond
->pName
))
{
*pResult
= pCond
->Code
;
return True
;
}
return False
;
}
static Boolean DecodeArgCondition
(unsigned Index
, Word
*pResult
)
{
Boolean Result
= DecodeCondition
(ArgStr
[Index
].
str.
p_str, pResult
);
if (!Result
)
WrStrErrorPos
(ErrNum_UndefCond
, &ArgStr
[Index
]);
return Result
;
}
static Boolean DecodeArgXIOCmd
(unsigned Index
, Word
*pResult
)
{
static const tCondition XIO
[] =
{
{ "SMK", 0x2000 },
{ "CLIR", 0x2001 },
{ "ENBL", 0x2002 },
{ "DSBL", 0x2003 },
{ "RPI", 0x2004 },
{ "SPI", 0x2005 },
{ "OD", 0x2008 },
{ "RNS", 0x200A },
{ "WSW", 0x200E },
{ "CO", 0x4000 },
{ "CLC", 0x4001 },
{ "MPEN", 0x4003 },
{ "ESUR", 0x4004 },
{ "DSUR", 0x4005 },
{ "DMAE", 0x4006 },
{ "DMAD", 0x4007 },
{ "TAS", 0x4008 },
{ "TAH", 0x4009 },
{ "OTA", 0x400A },
{ "GO", 0x400B },
{ "TBS", 0x400C },
{ "TBH", 0x400D },
{ "OTB", 0x400E },
{ "LMP", 0x5000 },
{ "WIPR", 0x5100 },
{ "WOPR", 0x5200 },
{ "RMP", 0xD000 },
{ "RIPR", 0xD100 },
{ "ROPR", 0xD200 },
{ "RMK", 0xA000 },
{ "RIC1", 0xA001 },
{ "RIC2", 0xA002 },
{ "RPIR", 0xA004 },
{ "RDOR", 0xA008 },
{ "RDI", 0xA009 },
{ "TPIO", 0xA00B },
{ "RMFS", 0xA00D },
{ "RSW", 0xA00E },
{ "RCFR", 0xA00F },
{ "CI", 0xC000 },
{ "RCS", 0xC001 },
{ "ITA", 0xC00A },
{ "ITB", 0xC00E },
{ NULL
, 0xFFFF }
};
const tCondition
*pRun
;
Boolean OK
;
if (isalpha(ArgStr
[Index
].
str.
p_str[0]))
{
for (pRun
= XIO
; pRun
->pName
; pRun
++)
if (!as_strcasecmp
(ArgStr
[Index
].
str.
p_str, pRun
->pName
))
{
*pResult
= pRun
->Code
;
return True
;
}
}
*pResult
= EvalStrIntExpression
(&ArgStr
[Index
], UInt16
, &OK
);
return OK
;
}
/*-------------------------------------------------------------------------*/
/* Code Generators */
static void DecodeNone
(Word Code
)
{
if (ChkArgCnt
(0, 0))
PutCode
(Code
);
}
static void DecodeR
(Word Code
)
{
Word Ra
, Rb
;
if (ChkArgCnt
(2, 2)
&& DecodeArgReg
(1, &Ra
)
&& DecodeArgReg
(2, &Rb
))
PutCode
(Code
| (Ra
<< 4) | Rb
);
}
static void DecodeRImm
(Word Code
)
{
Word N
, Rb
;
Boolean OK
;
if (ChkArgCnt
(2, 2) && DecodeArgReg
(1, &Rb
))
{
N
= EvalStrIntExpression
(&ArgStr
[2], UInt4
, &OK
);
if (OK
)
PutCode
(Code
| (N
<< 4) | Rb
);
}
}
static void DecodeIS
(Word Code
)
{
Word N
, Ra
;
Boolean OK
;
tSymbolFlags Flags
;
if (ChkArgCnt
(2, 2) && DecodeArgReg
(1, &Ra
))
{
N
= EvalStrIntExpressionWithFlags
(&ArgStr
[2], UInt5
, &OK
, &Flags
);
if (OK
&& mFirstPassUnknown
(Flags
))
N
= 1;
if (OK
&& ChkRange
(N
, 1, 16))
PutCode
(Code
| (Ra
<< 4) | (N
- 1));
}
}
static void DecodeMem
(Word Code
)
{
Word Ra
;
if (ChkArgCnt
(2, 3)
&& DecodeArgReg
(1, &Ra
)
&& DecodeAdr
(2, ArgCnt
))
{
PutCode
(Code
| (Ra
<< 4) | AdrReg
);
PutCode
(AdrWord
);
}
}
static void DecodeImOcx
(Word Code
)
{
Word Ra
;
if (ChkArgCnt
(2, 2) && DecodeArgReg
(1, &Ra
))
{
Boolean OK
;
Word ImmVal
= EvalStrIntExpression
(&ArgStr
[2], Int16
, &OK
);
if (OK
)
{
PutCode
(Code
| (Ra
<< 4));
PutCode
(ImmVal
);
}
}
}
static void DecodeB
(Word Code
)
{
Word Br
;
if (ChkArgCnt
(2, 2) && DecodeArgBaseReg
(1, &Br
))
{
Boolean OK
;
Word LoByte
= EvalStrIntExpression
(&ArgStr
[2], UInt8
, &OK
);
if (OK
)
PutCode
(Code
| (Br
<< 8) | LoByte
);
}
}
static void DecodeBX
(Word Code
)
{
Word Br
, Rx
;
if (!ChkArgCnt
(2, 2));
else if (!DecodeArgBaseReg
(1, &Br
));
else if (!DecodeArgReg
(2, &Rx
));
else if (0 == Rx
) WrXErrorPos
(ErrNum_InvAddrMode
, "!R0", &ArgStr
[2].
Pos);
else
PutCode
(Code
| (Br
<< 8) | Rx
);
}
static void DecodeICR
(Word Code
)
{
if (ChkArgCnt
(1, 1))
{
Boolean OK
;
tSymbolFlags Flags
;
LargeInt Diff
= EvalStrIntExpressionWithFlags
(&ArgStr
[1], UInt16
, &OK
, &Flags
) - EProgCounter
();
if (OK
)
{
if (!mSymbolQuestionable
(Flags
) && ((Diff
< -128) || (Diff
> 127))) WrError
(ErrNum_JmpDistTooBig
);
else
PutCode
(Code
| (Diff
& 0xff));
}
}
}
static void DecodeS
(Word Code
)
{
if (ChkArgCnt
(1, 1))
{
Boolean OK
;
Word Value
= EvalStrIntExpression
(&ArgStr
[1], UInt4
, &OK
);
if (OK
)
PutCode
(Code
| Value
);
}
}
static void DecodeIM1_16
(Word Code
)
{
if (ChkArgCnt
(2, 3) && DecodeAdr
(2, ArgCnt
))
{
Boolean OK
;
Word N
;
tSymbolFlags Flags
;
N
= EvalStrIntExpressionWithFlags
(&ArgStr
[1], UInt5
, &OK
, &Flags
);
if (OK
&& mFirstPassUnknown
(Flags
))
N
= 1;
if (OK
&& ChkRange
(N
, 1, 16))
{
PutCode
(Code
| ((N
- 1) << 4) | AdrReg
);
PutCode
(AdrWord
);
}
}
}
static void DecodeXMem
(Word Code
)
{
Word Ra
;
if (ChkArgCnt
(2, 3)
&& DecodeArgReg
(1, &Ra
)
&& DecodeAdr
(2, ArgCnt
))
{
PutCode
(Code
| (Ra
<< 4) | AdrReg
);
PutCode
(AdrWord
);
}
}
static void DecodeImmR
(Word Code
)
{
Word Rb
, N
;
Boolean OK
;
if (ChkArgCnt
(2, 2) && DecodeArgReg
(2, &Rb
))
{
N
= EvalStrIntExpression
(&ArgStr
[1], UInt4
, &OK
);
if (OK
)
PutCode
(Code
| (N
<< 4) | Rb
);
}
}
static void DecodeJump
(Word Code
)
{
Word Cond
;
if (ChkArgCnt
(2, 3)
&& DecodeArgCondition
(1, &Cond
)
&& DecodeAdr
(2, ArgCnt
))
{
PutCode
(Code
| (Cond
<< 4) | AdrReg
);
PutCode
(AdrWord
);
}
}
static void DecodeAddr
(Word Code
)
{
if (ChkArgCnt
(1, 2) && DecodeAdr
(1, ArgCnt
))
{
PutCode
(Code
| AdrReg
);
PutCode
(AdrWord
);
}
}
static void DecodeIM_0_15
(Word Code
)
{
if (ChkArgCnt
(2, 3) && DecodeAdr
(2, ArgCnt
))
{
Boolean OK
;
Word N
= EvalStrIntExpression
(&ArgStr
[1], UInt4
, &OK
);
if (OK
)
{
PutCode
(Code
| (N
<< 4) | AdrReg
);
PutCode
(AdrWord
);
}
}
}
static void DecodeSR
(Word Code
)
{
Word R
;
if (ChkArgCnt
(1, 1) && DecodeArgReg
(1, &R
))
PutCode
(Code
| (R
<< 4));
}
static void DecodeXIO
(Word Code
)
{
Word Ra
, Cmd
;
if (ChkArgCnt
(2, 3)
&& DecodeArgReg
(1, &Ra
)
&& DecodeArgXIOCmd
(2, &Cmd
))
{
if (ArgCnt
== 3)
{
Word Ri
;
if (!DecodeArgReg
(3, &Ri
));
else if (Ri
== 0) WrXErrorPos
(ErrNum_InvAddrMode
, "!R0", &ArgStr
[3].
Pos);
else
{
PutCode
(Code
| (Ra
<< 4) | Ri
);
PutCode
(Cmd
);
}
}
else
{
PutCode
(Code
| (Ra
<< 4));
PutCode
(Cmd
);
}
}
}
static void ShiftMantRight
(Byte Field
[8])
{
int Index
;
for (Index
= 7; Index
>= 1; Index
--)
Field
[Index
] = ((Field
[Index
] >> 1) & 0x7f) | ((Field
[Index
- 1] & 1) << 7);
}
static void ShiftMantLeft
(Byte Field
[8])
{
int Index
;
for (Index
= 1; Index
<= 7; Index
++)
{
Field
[Index
] = ((Field
[Index
] & 0x7f) << 1);
if (Index
< 7)
Field
[Index
] |= (Field
[Index
+ 1] >> 7) & 0x01;
}
}
static void DecodeFLOAT
(Word Extended
)
{
int z
;
Boolean OK
;
Double Value
;
Byte Field
[8];
Byte Sign
;
Word Exponent
, Word0
, Word1
, Word2
;
Integer SignedExponent
;
if (!ChkArgCnt
(1, ArgCntMax
))
return;
for (z
= 1; z
<= ArgCnt
; z
++)
{
Value
= EvalStrFloatExpression
(&ArgStr
[z
], Float64
, &OK
);
if (!OK
)
break;
/* get binary representation, big endian */
Double_2_ieee8
(Value
, Field
, True
);
#if 0
printf("Field 0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
Field
[0], Field
[1], Field
[2], Field
[3], Field
[4], Field
[5], Field
[6], Field
[7]);
#endif
/* split off sign & exponent */
Sign
= (Field
[0] > 0x7f);
Exponent
= (((Word
) Field
[0] & 0x7f) << 4) + (Field
[1] >> 4);
Field
[0] = 0;
Field
[1] &= 0x0f;
#if 0
printf("Sign %u Exponent %u Mantissa 0x%02x%02x%02x%02x%02x%02x%02x\n", Sign
, Exponent
,
Field
[1], Field
[2], Field
[3], Field
[4], Field
[5], Field
[6], Field
[7]);
#endif
/* 1750 format has no implicit leading one in mantissa; i.e. mantissa can only
represent values of 1 > mant >= -1. If number is not denormalized, we have to
increase the exponent and shift the mantissa by one to the right: */
if (Exponent
> 0)
{
Field
[1] |= 0x10; /* make leading one explicit */
Exponent
++;
ShiftMantRight
(Field
);
}
/* If exponent is too small to represent, shift down mantissa
until exponent is large enough, or mantissa is all-zeroes: */
while (Exponent
< 1023 - 128)
{
Exponent
++;
ShiftMantRight
(Field
);
/* todo: regord only relevant bits of mantissa */
if (!(Field
[1] | Field
[2] | Field
[3] | Field
[4] | Field
[5] | Field
[6] | Field
[7]))
{
Exponent
= 0;
break;
}
}
SignedExponent
= Exponent
- 1023;
/* exponent overflow? */
if (SignedExponent
> 127)
{
WrError
(ErrNum_OverRange
);
break;
}
#if 0
printf("Sign %u SignedExponent %d Mantissa 0x%02x%02x%02x%02x%02x%02x%02x\n", Sign
, SignedExponent
,
Field
[1], Field
[2], Field
[3], Field
[4], Field
[5], Field
[6], Field
[7]);
#endif
/* form 2s complement of mantissa when sign is set */
if (Sign
)
{
/* 2s complement range is asymmetric: we can represent -1.0 in the
mantissa, but not +1.0. So if the mantissa is +0.5, and the
exponent is not at minimum, convert it to +1.0 and decrement the
exponent: */
if ((Field
[1] == 0x08) && !Field
[2] && !Field
[3] && !Field
[4]
&& !Field
[5] && !Field
[6] && !Field
[7] && (SignedExponent
> -127))
{
ShiftMantLeft
(Field
);
SignedExponent
--;
}
Field
[7] ^= 0xff;
Field
[6] ^= 0xff;
Field
[5] ^= 0xff;
Field
[4] ^= 0xff;
Field
[3] ^= 0xff;
Field
[2] ^= 0xff;
Field
[1] ^= 0x1f;
if (!(++Field
[7]))
if (!(++Field
[6]))
if (!(++Field
[5]))
if (!(++Field
[4]))
if (!(++Field
[3]))
if (!(++Field
[2]))
Field
[1] = (Field
[1] + 1) & 0x1f;
}
/* assemble mantissa */
/* TODO: mantissa rounding? */
Word0
= ((Word
)(Field
[1] & 0x1f) << 11) | ((Word
)Field
[2] << 3) | ((Field
[3] >> 5) & 0x07);
Word1
= ((Word
)(Field
[3] & 0x1f) << 11) | ((Word
)(Field
[4] & 0xe0) << 3);
if (Extended
)
Word2
= ((Word
)(Field
[4] & 0x1f) << 11) | ((Word
)Field
[5] << 3) | ((Field
[6] >> 5) & 0x07);
else
Word2
= 0;
/* zero mantissa means zero exponent */
if (!Word0
&& !Word1
&& !Word2
);
else
Word1
|= (SignedExponent
& 0xff);
/* now copy the mantissa to the destination */
PutCode
(Word0
);
PutCode
(Word1
);
if (Extended
)
PutCode
(Word2
);
}
}
static void DecodeDATA_1750
(Word Code
)
{
UNUSED
(Code
);
DecodeDATA
(UInt16
, UInt16
);
}
/*-------------------------------------------------------------------------*/
/* dynamic code table handling */
static void InitFields
(void)
{
InstTable
= CreateInstTable
(403);
AddInstTable
(InstTable
, "AISP", 0xA200, DecodeIS
);
AddInstTable
(InstTable
, "AIM", 0x4A01, DecodeImOcx
);
AddInstTable
(InstTable
, "AR", 0xA100, DecodeR
);
AddInstTable
(InstTable
, "A", 0xA000, DecodeMem
);
AddInstTable
(InstTable
, "ANDM", 0x4A07, DecodeImOcx
);
AddInstTable
(InstTable
, "ANDR", 0xE300, DecodeR
);
AddInstTable
(InstTable
, "AND", 0xE200, DecodeMem
);
AddInstTable
(InstTable
, "ABS", 0xA400, DecodeR
);
AddInstTable
(InstTable
, "AB", 0x1000, DecodeB
);
AddInstTable
(InstTable
, "ANDB", 0x3400, DecodeB
);
AddInstTable
(InstTable
, "ABX", 0x4040, DecodeBX
);
AddInstTable
(InstTable
, "ANDX", 0x40E0, DecodeBX
);
AddInstTable
(InstTable
, "BEZ", 0x7500, DecodeICR
);
AddInstTable
(InstTable
, "BNZ", 0x7A00, DecodeICR
);
AddInstTable
(InstTable
, "BGT", 0x7900, DecodeICR
);
AddInstTable
(InstTable
, "BLE", 0x7800, DecodeICR
);
AddInstTable
(InstTable
, "BGE", 0x7B00, DecodeICR
);
AddInstTable
(InstTable
, "BLT", 0x7600, DecodeICR
);
AddInstTable
(InstTable
, "BR", 0x7400, DecodeICR
);
AddInstTable
(InstTable
, "BEX", 0x7700, DecodeS
);
AddInstTable
(InstTable
, "BPT", 0xFFFF, DecodeNone
);
AddInstTable
(InstTable
, "BIF", 0x4F00, DecodeS
);
AddInstTable
(InstTable
, "CISP", 0xF200, DecodeIS
);
AddInstTable
(InstTable
, "CIM", 0x4A0A, DecodeImOcx
);
AddInstTable
(InstTable
, "CR", 0xF100, DecodeR
);
AddInstTable
(InstTable
, "C", 0xF000, DecodeMem
);
AddInstTable
(InstTable
, "CISN", 0xF300, DecodeIS
);
AddInstTable
(InstTable
, "CB", 0x3800, DecodeB
);
AddInstTable
(InstTable
, "CBL", 0xF400, DecodeMem
);
AddInstTable
(InstTable
, "CBX", 0x40C0, DecodeBX
);
AddInstTable
(InstTable
, "DLR", 0x8700, DecodeR
);
AddInstTable
(InstTable
, "DL", 0x8600, DecodeMem
);
AddInstTable
(InstTable
, "DST", 0x9600, DecodeMem
);
AddInstTable
(InstTable
, "DSLL", 0x6500, DecodeRImm
);
AddInstTable
(InstTable
, "DSRL", 0x6600, DecodeRImm
);
AddInstTable
(InstTable
, "DSRA", 0x6700, DecodeRImm
);
AddInstTable
(InstTable
, "DSLC", 0x6800, DecodeRImm
);
AddInstTable
(InstTable
, "DSLR", 0x6D00, DecodeR
);
AddInstTable
(InstTable
, "DSAR", 0x6E00, DecodeR
);
AddInstTable
(InstTable
, "DSCR", 0x6F00, DecodeR
);
AddInstTable
(InstTable
, "DECM", 0xB300, DecodeIM1_16
);
AddInstTable
(InstTable
, "DAR", 0xA700, DecodeR
);
AddInstTable
(InstTable
, "DA", 0xA600, DecodeMem
);
AddInstTable
(InstTable
, "DSR", 0xB700, DecodeR
);
AddInstTable
(InstTable
, "DS", 0xB600, DecodeMem
);
AddInstTable
(InstTable
, "DMR", 0xC700, DecodeR
);
AddInstTable
(InstTable
, "DM", 0xC600, DecodeMem
);
AddInstTable
(InstTable
, "DDR", 0xD700, DecodeR
);
AddInstTable
(InstTable
, "DD", 0xD600, DecodeMem
);
AddInstTable
(InstTable
, "DCR", 0xF700, DecodeR
);
AddInstTable
(InstTable
, "DC", 0xF600, DecodeMem
);
AddInstTable
(InstTable
, "DLB", 0x0400, DecodeB
);
AddInstTable
(InstTable
, "DSTB", 0x0C00, DecodeB
);
AddInstTable
(InstTable
, "DNEG", 0xB500, DecodeR
);
AddInstTable
(InstTable
, "DABS", 0xA500, DecodeR
);
AddInstTable
(InstTable
, "DR", 0xD500, DecodeR
);
AddInstTable
(InstTable
, "D", 0xD400, DecodeMem
);
AddInstTable
(InstTable
, "DISP", 0xD200, DecodeIS
);
AddInstTable
(InstTable
, "DIM", 0x4A05, DecodeImOcx
);
AddInstTable
(InstTable
, "DISN", 0xD300, DecodeIS
);
AddInstTable
(InstTable
, "DVIM", 0x4A06, DecodeImOcx
);
AddInstTable
(InstTable
, "DVR", 0xD100, DecodeR
);
AddInstTable
(InstTable
, "DV", 0xD000, DecodeMem
);
AddInstTable
(InstTable
, "DLI", 0x8800, DecodeMem
);
AddInstTable
(InstTable
, "DSTI", 0x9800, DecodeMem
);
AddInstTable
(InstTable
, "DB", 0x1C00, DecodeB
);
AddInstTable
(InstTable
, "DBX", 0x4070, DecodeBX
);
AddInstTable
(InstTable
, "DLBX", 0x4010, DecodeBX
);
AddInstTable
(InstTable
, "DSTX", 0x4030, DecodeBX
);
AddInstTable
(InstTable
, "DLE", 0xDF00, DecodeXMem
);
AddInstTable
(InstTable
, "DSTE", 0xDD00, DecodeXMem
);
AddInstTable
(InstTable
, "EFL", 0x8A00, DecodeMem
);
AddInstTable
(InstTable
, "EFST", 0x9A00, DecodeMem
);
AddInstTable
(InstTable
, "EFCR", 0xFB00, DecodeR
);
AddInstTable
(InstTable
, "EFC", 0xFA00, DecodeMem
);
AddInstTable
(InstTable
, "EFAR", 0xAB00, DecodeR
);
AddInstTable
(InstTable
, "EFA", 0xAA00, DecodeMem
);
AddInstTable
(InstTable
, "EFSR", 0xBB00, DecodeR
);
AddInstTable
(InstTable
, "EFS", 0xBA00, DecodeMem
);
AddInstTable
(InstTable
, "EFMR", 0xCB00, DecodeR
);
AddInstTable
(InstTable
, "EFM", 0xCA00, DecodeMem
);
AddInstTable
(InstTable
, "EFDR", 0xDB00, DecodeR
);
AddInstTable
(InstTable
, "EFD", 0xDA00, DecodeMem
);
AddInstTable
(InstTable
, "EFLT", 0xEB00, DecodeR
);
AddInstTable
(InstTable
, "EFIX", 0xEA00, DecodeR
);
AddInstTable
(InstTable
, "FAR", 0xA900, DecodeR
);
AddInstTable
(InstTable
, "FA", 0xA800, DecodeMem
);
AddInstTable
(InstTable
, "FSR", 0xB900, DecodeR
);
AddInstTable
(InstTable
, "FS", 0xB800, DecodeMem
);
AddInstTable
(InstTable
, "FMR", 0xC900, DecodeR
);
AddInstTable
(InstTable
, "FM", 0xC800, DecodeMem
);
AddInstTable
(InstTable
, "FDR", 0xD900, DecodeR
);
AddInstTable
(InstTable
, "FD", 0xD800, DecodeMem
);
AddInstTable
(InstTable
, "FCR", 0xF900, DecodeR
);
AddInstTable
(InstTable
, "FC", 0xF800, DecodeMem
);
AddInstTable
(InstTable
, "FABS", 0xAC00, DecodeR
);
AddInstTable
(InstTable
, "FIX", 0xE800, DecodeR
);
AddInstTable
(InstTable
, "FLT", 0xE900, DecodeR
);
AddInstTable
(InstTable
, "FNEG", 0xBC00, DecodeR
);
AddInstTable
(InstTable
, "FAB", 0x2000, DecodeB
);
AddInstTable
(InstTable
, "FABX", 0x4080, DecodeBX
);
AddInstTable
(InstTable
, "FSB", 0x2400, DecodeB
);
AddInstTable
(InstTable
, "FSBX", 0x4090, DecodeBX
);
AddInstTable
(InstTable
, "FMB", 0x2800, DecodeB
);
AddInstTable
(InstTable
, "FMBX", 0x40A0, DecodeBX
);
AddInstTable
(InstTable
, "FDB", 0x2C00, DecodeB
);
AddInstTable
(InstTable
, "FDBX", 0x40B0, DecodeBX
);
AddInstTable
(InstTable
, "FCB", 0x3C00, DecodeB
);
AddInstTable
(InstTable
, "FCBX", 0x40D0, DecodeBX
);
AddInstTable
(InstTable
, "INCM", 0xA300, DecodeIM1_16
);
AddInstTable
(InstTable
, "JC", 0x7000, DecodeJump
);
AddInstTable
(InstTable
, "J", 0x7400, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JEZ", 0x7500, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JLE", 0x7800, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JGT", 0x7900, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JNZ", 0x7A00, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JGE", 0x7B00, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JLT", 0x7600, DecodeICR
); /* TBD (GAS) */
AddInstTable
(InstTable
, "JCI", 0x7100, DecodeJump
);
AddInstTable
(InstTable
, "JS", 0x7200, DecodeMem
);
AddInstTable
(InstTable
, "LISP", 0x8200, DecodeIS
);
AddInstTable
(InstTable
, "LIM", 0x8500, DecodeMem
);
AddInstTable
(InstTable
, "LR", 0x8100, DecodeR
);
AddInstTable
(InstTable
, "L", 0x8000, DecodeMem
);
AddInstTable
(InstTable
, "LISN", 0x8300, DecodeIS
);
AddInstTable
(InstTable
, "LB", 0x0000, DecodeB
);
AddInstTable
(InstTable
, "LBX", 0x4000, DecodeBX
);
AddInstTable
(InstTable
, "LSTI", 0x7C00, DecodeAddr
);
AddInstTable
(InstTable
, "LST", 0x7D00, DecodeAddr
);
AddInstTable
(InstTable
, "LI", 0x8400, DecodeMem
);
AddInstTable
(InstTable
, "LM", 0x8900, DecodeIM_0_15
);
AddInstTable
(InstTable
, "LUB", 0x8B00, DecodeMem
);
AddInstTable
(InstTable
, "LLB", 0x8C00, DecodeMem
);
AddInstTable
(InstTable
, "LUBI", 0x8D00, DecodeMem
);
AddInstTable
(InstTable
, "LLBI", 0x8E00, DecodeMem
);
AddInstTable
(InstTable
, "LE", 0xDE00, DecodeXMem
);
AddInstTable
(InstTable
, "MISP", 0xC200, DecodeIS
);
AddInstTable
(InstTable
, "MSIM", 0x4A04, DecodeImOcx
);
AddInstTable
(InstTable
, "MSR", 0xC100, DecodeR
);
AddInstTable
(InstTable
, "MS", 0xC000, DecodeMem
);
AddInstTable
(InstTable
, "MISN", 0xC300, DecodeIS
);
AddInstTable
(InstTable
, "MIM", 0x4A03, DecodeImOcx
);
AddInstTable
(InstTable
, "MR", 0xC500, DecodeR
);
AddInstTable
(InstTable
, "M", 0xC400, DecodeMem
);
AddInstTable
(InstTable
, "MOV", 0x9300, DecodeR
);
AddInstTable
(InstTable
, "MB", 0x1800, DecodeB
);
AddInstTable
(InstTable
, "MBX", 0x4060, DecodeBX
);
AddInstTable
(InstTable
, "NEG", 0xB400, DecodeR
);
AddInstTable
(InstTable
, "NOP", 0xFF00, DecodeNone
);
AddInstTable
(InstTable
, "NIM", 0x4A0B, DecodeImOcx
);
AddInstTable
(InstTable
, "NR", 0xE700, DecodeR
);
AddInstTable
(InstTable
, "N", 0xE600, DecodeMem
);
AddInstTable
(InstTable
, "ORIM", 0x4A08, DecodeImOcx
);
AddInstTable
(InstTable
, "ORR", 0xE100, DecodeR
);
AddInstTable
(InstTable
, "OR", 0xE000, DecodeMem
);
AddInstTable
(InstTable
, "ORB", 0x3000, DecodeB
);
AddInstTable
(InstTable
, "ORBX", 0x40F0, DecodeBX
);
AddInstTable
(InstTable
, "PSHM", 0x9F00, DecodeR
);
AddInstTable
(InstTable
, "POPM", 0x8F00, DecodeR
);
AddInstTable
(InstTable
, "RBR", 0x5400, DecodeImmR
);
AddInstTable
(InstTable
, "RVBR", 0x5C00, DecodeR
);
AddInstTable
(InstTable
, "RB", 0x5300, DecodeIM_0_15
);
AddInstTable
(InstTable
, "RBI", 0x5500, DecodeIM_0_15
);
AddInstTable
(InstTable
, "ST", 0x9000, DecodeMem
);
AddInstTable
(InstTable
, "STC", 0x9100, DecodeIM_0_15
);
AddInstTable
(InstTable
, "SISP", 0xB200, DecodeIS
);
AddInstTable
(InstTable
, "SIM", 0x4A02, DecodeImOcx
);
AddInstTable
(InstTable
, "SR", 0xB100, DecodeR
);
AddInstTable
(InstTable
, "S", 0xB000, DecodeMem
);
AddInstTable
(InstTable
, "SLL", 0x6000, DecodeRImm
);
AddInstTable
(InstTable
, "SRL", 0x6100, DecodeRImm
);
AddInstTable
(InstTable
, "SRA", 0x6200, DecodeRImm
);
AddInstTable
(InstTable
, "SLC", 0x6300, DecodeRImm
);
AddInstTable
(InstTable
, "SLR", 0x6A00, DecodeR
);
AddInstTable
(InstTable
, "SAR", 0x6B00, DecodeR
);
AddInstTable
(InstTable
, "SCR", 0x6C00, DecodeR
);
AddInstTable
(InstTable
, "SJS", 0x7E00, DecodeMem
);
AddInstTable
(InstTable
, "STB", 0x0800, DecodeB
);
AddInstTable
(InstTable
, "SBR", 0x5100, DecodeImmR
);
AddInstTable
(InstTable
, "SB", 0x5000, DecodeIM_0_15
);
AddInstTable
(InstTable
, "SVBR", 0x5A00, DecodeR
);
AddInstTable
(InstTable
, "SOJ", 0x7300, DecodeMem
);
AddInstTable
(InstTable
, "SBB", 0x1400, DecodeB
);
AddInstTable
(InstTable
, "STBX", 0x4020, DecodeBX
);
AddInstTable
(InstTable
, "SBBX", 0x4050, DecodeBX
);
AddInstTable
(InstTable
, "SBI", 0x5200, DecodeIM_0_15
);
AddInstTable
(InstTable
, "STZ", 0x9100, DecodeAddr
);
AddInstTable
(InstTable
, "STCI", 0x9200, DecodeIM_0_15
);
AddInstTable
(InstTable
, "STI", 0x9400, DecodeMem
);
AddInstTable
(InstTable
, "SFBS", 0x9500, DecodeR
);
AddInstTable
(InstTable
, "SRM", 0x9700, DecodeMem
);
AddInstTable
(InstTable
, "STM", 0x9900, DecodeIM_0_15
);
AddInstTable
(InstTable
, "STUB", 0x9B00, DecodeMem
);
AddInstTable
(InstTable
, "STLB", 0x9C00, DecodeMem
);
AddInstTable
(InstTable
, "SUBI", 0x9D00, DecodeMem
);
AddInstTable
(InstTable
, "SLBI", 0x9E00, DecodeMem
);
AddInstTable
(InstTable
, "STE", 0xDC00, DecodeXMem
);
AddInstTable
(InstTable
, "TBR", 0x5700, DecodeImmR
);
AddInstTable
(InstTable
, "TB", 0x5600, DecodeIM_0_15
);
AddInstTable
(InstTable
, "TBI", 0x5800, DecodeIM_0_15
);
AddInstTable
(InstTable
, "TSB", 0x5900, DecodeIM_0_15
);
AddInstTable
(InstTable
, "TVBR", 0x5E00, DecodeR
);
AddInstTable
(InstTable
, "URS", 0x7F00, DecodeSR
);
AddInstTable
(InstTable
, "UAR", 0xAD00, DecodeR
);
AddInstTable
(InstTable
, "UA", 0xAE00, DecodeMem
);
AddInstTable
(InstTable
, "USR", 0xBD00, DecodeR
);
AddInstTable
(InstTable
, "US", 0xBE00, DecodeMem
);
AddInstTable
(InstTable
, "UCIM", 0xF500, DecodeImOcx
);
AddInstTable
(InstTable
, "UCR", 0xFC00, DecodeR
);
AddInstTable
(InstTable
, "UC", 0xFD00, DecodeMem
);
AddInstTable
(InstTable
, "VIO", 0x4900, DecodeMem
);
AddInstTable
(InstTable
, "XORR", 0xE500, DecodeR
);
AddInstTable
(InstTable
, "XORM", 0x4A09, DecodeImOcx
);
AddInstTable
(InstTable
, "XOR", 0xE400, DecodeMem
);
AddInstTable
(InstTable
, "XWR", 0xED00, DecodeR
);
AddInstTable
(InstTable
, "XBR", 0xEC00, DecodeSR
);
AddInstTable
(InstTable
, "XIO", 0x4800, DecodeXIO
);
AddInstTable
(InstTable
, "FLOAT", 0, DecodeFLOAT
);
AddInstTable
(InstTable
, "EXTENDED", 1, DecodeFLOAT
);
AddInstTable
(InstTable
, "DATA", 0, DecodeDATA_1750
);
}
static void DeinitFields
(void)
{
DestroyInstTable
(InstTable
);
}
/*-------------------------------------------------------------------------*/
/* interface to common layer */
static void MakeCode_1750
(void)
{
CodeLen
= 0; DontPrint
= False
;
/* zu ignorierendes */
if (Memo
(""))
return;
if (!LookupInstTable
(InstTable
, OpPart.
str.
p_str))
WrStrErrorPos
(ErrNum_UnknownInstruction
, &OpPart
);
}
static Boolean IsDef_1750
(void)
{
return Memo
("BIT");
}
static void SwitchFrom_1750
(void)
{
DeinitFields
();
}
static void SwitchTo_1750
(void)
{
const TFamilyDescr
*pDescr
;
pDescr
= FindFamilyByName
("1750");
TurnWords
= False
;
SetIntConstMode
(eIntConstModeIntel
);
PCSymbol
= "$";
HeaderID
= pDescr
->Id
;
NOPCode
= 0xff00;
DivideChars
= ",";
HasAttrs
= False
;
ValidSegs
= 1 << SegCode
;
Grans
[SegCode
] = 2; ListGrans
[SegCode
] = 2; SegInits
[SegCode
] = 0;
SegLimits
[SegCode
] = 0xffff;
ASSUMERecCnt
= 0;
MakeCode
= MakeCode_1750
;
IsDef
= IsDef_1750
;
SwitchFrom
= SwitchFrom_1750
; InitFields
();
}
void code1750_init
(void)
{
CPU1750
= AddCPU
("1750", SwitchTo_1750
);
AddCopyright
("MIL-STD 1750 Generator also (C) 2019 Oliver Kellogg");
}