WebSVN – pentevo – Blame – //tools/asl/asl-current/code370.c

Rev	Author	Line No.	Line
1186	savelij	1	/* code370.c */
		2	/*****************************************************************************/
		3	/* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only */
		4	/* */
		5	/* AS-Portierung */
		6	/* */
		7	/* Codegenerator 370-Familie */
		8	/* */
		9	/*****************************************************************************/
		10
		11	#include "stdinc.h"
		12
		13	#include <ctype.h>
		14	#include <string.h>
		15
		16	#include "bpemu.h"
		17	#include "strutil.h"
		18	#include "asmdef.h"
		19	#include "asmsub.h"
		20	#include "asmpars.h"
		21	#include "asmitree.h"
		22	#include "intformat.h"
		23	#include "codepseudo.h"
		24	#include "intpseudo.h"
		25	#include "codevars.h"
		26	#include "errmsg.h"
		27
		28	#include "code370.h"
		29
		30	typedef struct
		31	{
		32	char *Name;
		33	Word Code;
		34	} FixedOrder;
		35
		36	enum
		37	{
		38	ModNone = -1,
		39	ModAccA = 0, /* A */
		40	ModAccB = 1, /* B */
		41	ModReg = 2, /* Rn */
		42	ModPort = 3, /* Pn */
		43	ModAbs = 4, /* nnnn */
		44	ModBRel = 5, /* nnnn(B) */
		45	ModSPRel = 6, /* nn(SP) */
		46	ModIReg = 7, /* @Rn */
		47	ModRegRel = 8, /* nn(Rn) */
		48	ModImm = 9, /* #nn */
		49	ModImmBRel = 10, /* #nnnn(B) */
		50	ModImmRegRel = 11 /* #nn(Rm) */
		51	};
		52
		53	#define MModAccA (1 << ModAccA)
		54	#define MModAccB (1 << ModAccB)
		55	#define MModReg (1 << ModReg)
		56	#define MModPort (1 << ModPort)
		57	#define MModAbs (1 << ModAbs)
		58	#define MModBRel (1 << ModBRel)
		59	#define MModSPRel (1 << ModSPRel)
		60	#define MModIReg (1 << ModIReg)
		61	#define MModRegRel (1 << ModRegRel)
		62	#define MModImm (1 << ModImm)
		63	#define MModImmBRel (1 << ModImmBRel)
		64	#define MModImmRegRel (1 << ModImmRegRel)
		65
		66	static CPUVar CPU37010, CPU37020, CPU37030, CPU37040, CPU37050;
		67
		68	static Byte OpSize;
		69	static ShortInt AdrType;
		70	static Byte AdrVals[2];
		71
		72	/****************************************************************************/
		73
		74	static char HasDisp(char Asc)
		75	{
		76	char *p;
		77	int Lev;
		78
		79	if ((*Asc) && (Asc[strlen(Asc) - 1] == ')'))
		80	{
		81	p = Asc + strlen(Asc) - 2;
		82	Lev = 0;
		83	while ((p >= Asc) && (Lev != -1))
		84	{
		85	switch (*p)
		86	{
		87	case '(': Lev--; break;
		88	case ')': Lev++; break;
		89	}
		90	if (Lev != -1)
		91	p--;
		92	}
		93	if (p < Asc)
		94	{
		95	WrXError(ErrNum_BrackErr, Asc);
		96	return NULL;
		97	}
		98	}
		99	else
		100	p = NULL;
		101
		102	return p;
		103	}
		104
		105	static void DecodeAdrRel(const tStrComp *pArg, Word Mask, Boolean AddrRel)
		106	{
		107	Integer HVal;
		108	char *p;
		109	Boolean OK;
		110
		111	AdrType = ModNone;
		112	AdrCnt = 0;
		113
		114	if (!as_strcasecmp(pArg->str.p_str, "A"))
		115	{
		116	if (Mask & MModAccA)
		117	AdrType = ModAccA;
		118	else if (Mask & MModReg)
		119	{
		120	AdrCnt = 1;
		121	AdrVals[0] = 0;
		122	AdrType = ModReg;
		123	}
		124	else
		125	{
		126	AdrCnt = 2;
		127	AdrVals[0] = 0;
		128	AdrVals[1] = 0;
		129	AdrType = ModAbs;
		130	}
		131	goto chk;
		132	}
		133
		134	if (!as_strcasecmp(pArg->str.p_str, "B"))
		135	{
		136	if (Mask & MModAccB)
		137	AdrType = ModAccB;
		138	else if (Mask & MModReg)
		139	{
		140	AdrCnt = 1;
		141	AdrVals[0] = 1;
		142	AdrType = ModReg;
		143	}
		144	else
		145	{
		146	AdrCnt = 2;
		147	AdrVals[0] = 0;
		148	AdrVals[1] = 1;
		149	AdrType = ModAbs;
		150	}
		151	goto chk;
		152	}
		153
		154	if (*pArg->str.p_str == '#')
		155	{
		156	tStrComp Arg;
		157
		158	StrCompRefRight(&Arg, pArg, 1);
		159	p = HasDisp(Arg.str.p_str);
		160	if (!p)
		161	{
		162	switch (OpSize)
		163	{
		164	case 0:
		165	AdrVals[0] = EvalStrIntExpression(&Arg, Int8, &OK);
		166	break;
		167	case 1:
		168	HVal = EvalStrIntExpression(&Arg, Int16, &OK);
		169	AdrVals[0] = Hi(HVal); AdrVals[1] = Lo(HVal);
		170	break;
		171	}
		172	if (OK)
		173	{
		174	AdrCnt = 1 + OpSize;
		175	AdrType = ModImm;
		176	}
		177	}
		178	else
		179	{
		180	tStrComp Left, Right;
		181	tSymbolFlags Flags;
		182
		183	StrCompSplitRef(&Left, &Right, &Arg, p);
		184	if (Left.str.p_str[0])
		185	HVal = EvalStrIntExpressionWithFlags(&Left, Int16, &OK, &Flags);
		186	else
		187	{
		188	HVal = 0;
		189	OK = True;
		190	Flags = eSymbolFlag_None;
		191	}
		192	if (OK)
		193	{
		194	*p = '(';
		195	if (!as_strcasecmp(p, "(B)"))
		196	{
		197	AdrVals[0] = Hi(HVal);
		198	AdrVals[1] = Lo(HVal);
		199	AdrCnt = 2;
		200	AdrType = ModImmBRel;
		201	}
		202	else
		203	{
		204	if (mFirstPassUnknown(Flags))
		205	HVal &= 127;
		206	if (ChkRange(HVal, -128, 127))
		207	{
		208	AdrVals[0] = HVal & 0xff;
		209	AdrCnt = 1;
		210	AdrVals[1] = EvalStrIntExpression(&Arg, UInt8, &OK);
		211	if (OK)
		212	{
		213	AdrCnt = 2;
		214	AdrType = ModImmRegRel;
		215	}
		216	}
		217	}
		218	}
		219	}
		220	goto chk;
		221	}
		222
		223	if (*pArg->str.p_str == '@')
		224	{
		225	AdrVals[0] = EvalStrIntExpressionOffs(pArg, 1, Int8, &OK);
		226	if (OK)
		227	{
		228	AdrCnt = 1;
		229	AdrType = ModIReg;
		230	}
		231	goto chk;
		232	}
		233
		234	p = HasDisp(pArg->str.p_str);
		235
		236	if (!p)
		237	{
		238	HVal = EvalStrIntExpression(pArg, Int16, &OK);
		239	if (OK)
		240	{
		241	if (((Mask & MModReg) != 0) && (Hi(HVal) == 0))
		242	{
		243	AdrVals[0] = Lo(HVal);
		244	AdrCnt = 1;
		245	AdrType = ModReg;
		246	}
		247	else if (((Mask & MModPort) != 0) && (Hi(HVal) == 0x10))
		248	{
		249	AdrVals[0] = Lo(HVal);
		250	AdrCnt = 1;
		251	AdrType = ModPort;
		252	}
		253	else
		254	{
		255	if (AddrRel)
		256	HVal -= EProgCounter() + 3;
		257	AdrVals[0] = Hi(HVal);
		258	AdrVals[1] = Lo(HVal);
		259	AdrCnt = 2;
		260	AdrType = ModAbs;
		261	}
		262	}
		263	goto chk;
		264	}
		265	else
		266	{
		267	tStrComp Left, Right;
		268	tSymbolFlags Flags;
		269
		270	StrCompSplitRef(&Left, &Right, pArg, p);
		271	HVal = EvalStrIntExpressionWithFlags(&Left, Int16, &OK, &Flags);
		272	if (mFirstPassUnknown(Flags))
		273	HVal &= 0x7f;
		274	if (OK)
		275	{
		276	StrCompShorten (&Right, 1);
		277	if (!as_strcasecmp(Right.str.p_str, "B"))
		278	{
		279	if (AddrRel)
		280	HVal -= EProgCounter() + 3;
		281	AdrVals[0] = Hi(HVal);
		282	AdrVals[1] = Lo(HVal);
		283	AdrCnt = 2;
		284	AdrType = ModBRel;
		285	}
		286	else if (!as_strcasecmp(Right.str.p_str, "SP"))
		287	{
		288	if (AddrRel)
		289	HVal -= EProgCounter() + 3;
		290	if (HVal > 127) WrError(ErrNum_OverRange);
		291	else if (HVal < -128) WrError(ErrNum_UnderRange);
		292	else
		293	{
		294	AdrVals[0] = HVal & 0xff;
		295	AdrCnt = 1;
		296	AdrType = ModSPRel;
		297	}
		298	}
		299	else
		300	{
		301	if (HVal > 127) WrError(ErrNum_OverRange);
		302	else if (HVal < -128) WrError(ErrNum_UnderRange);
		303	else
		304	{
		305	AdrVals[0] = HVal & 0xff;
		306	AdrVals[1] = EvalStrIntExpression(&Right, Int8, &OK);
		307	if (OK)
		308	{
		309	AdrCnt = 2;
		310	AdrType = ModRegRel;
		311	}
		312	}
		313	}
		314	}
		315	goto chk;
		316	}
		317
		318	chk:
		319	if ((AdrType != ModNone) && (!(Mask & (1 << AdrType))))
		320	{
		321	WrError(ErrNum_InvAddrMode);
		322	AdrType = ModNone;
		323	AdrCnt = 0;
		324	}
		325	}
		326
		327	static void DecodeAdr(const tStrComp *pArg, Word Mask)
		328	{
		329	DecodeAdrRel(pArg, Mask, FALSE);
		330	}
		331
		332	static void PutCode(Word Code)
		333	{
		334	if (Hi(Code) == 0)
		335	{
		336	CodeLen = 1;
		337	BAsmCode[0] = Code;
		338	}
		339	else
		340	{
		341	CodeLen = 2;
		342	BAsmCode[0] = Hi(Code);
		343	BAsmCode[1] = Lo(Code);
		344	}
		345	}
		346
		347	static void DissectBitValue(LargeWord Symbol, Word pAddr, Byte pBit)
		348	{
		349	*pAddr = Symbol & 0xffff;
		350	*pBit = (Symbol >> 16) & 7;
		351	}
		352
		353	static void DissectBit_370(char *pDest, size_t DestSize, LargeWord Symbol)
		354	{
		355	Word Addr;
		356	Byte Bit;
		357
		358	DissectBitValue(Symbol, &Addr, &Bit);
		359
		360	if (Addr < 2)
		361	as_snprintf(pDest, DestSize, "%c", HexStartCharacter + Addr);
		362	else
		363	as_snprintf(pDest, DestSize, "%~0.*u%s",
		364	ListRadixBase, (unsigned)Addr, GetIntConstIntelSuffix(ListRadixBase));
		365	as_snprcatf(pDest, DestSize, ".%c", Bit + '0');
		366	}
		367
		368	static Boolean DecodeBitExpr(int Start, int Stop, LongWord *pResult)
		369	{
		370	Boolean OK;
		371
		372	if (Start == Stop)
		373	{
		374	*pResult = EvalStrIntExpression(&ArgStr[Start], UInt19, &OK);
		375	return OK;
		376	}
		377	else
		378	{
		379	Byte Bit;
		380	Word Addr;
		381
		382	Bit = EvalStrIntExpression(&ArgStr[Start], UInt3, &OK);
		383	if (!OK)
		384	return OK;
		385
		386	if ((!as_strcasecmp(ArgStr[Stop].str.p_str, "A")) \|\| (!as_strcasecmp(ArgStr[Stop].str.p_str, "B")))
		387	{
		388	Addr = toupper(*ArgStr[Stop].str.p_str) - 'A';
		389	OK = True;
		390	}
		391	else
		392	{
		393	tSymbolFlags Flags;
		394
		395	Addr = EvalStrIntExpressionWithFlags(&ArgStr[Stop], UInt16, &OK, &Flags);
		396	if (!OK)
		397	return OK;
		398	if (mFirstPassUnknown(Flags))
		399	Addr &= 0xff;
		400	if (Addr & 0xef00) /* 00h...0ffh, 1000h...10ffh allowed */
		401	{
		402	WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[Stop]);
		403	return False;
		404	}
		405	}
		406
		407	*pResult = (((LongWord)Bit) << 16) + Addr;
		408	return True;
		409	}
		410	}
		411
		412	/****************************************************************************/
		413
		414	static void DecodeFixed(Word Code)
		415	{
		416	if (ChkArgCnt(0, 0))
		417	PutCode(Code);
		418	}
		419
		420	static void DecodeDBIT(Word Code)
		421	{
		422	LongWord Value;
		423
		424	UNUSED(Code);
		425
		426	if (ChkArgCnt(1, 2) && DecodeBitExpr(1, ArgCnt, &Value))
		427	{
		428	PushLocHandle(-1);
		429	EnterIntSymbol(&LabPart, Value, SegBData, False);
		430	*ListLine = '=';
		431	DissectBit_370(ListLine + 1, STRINGSIZE - 1, Value);
		432	PopLocHandle();
		433	}
		434	}
		435
		436	static void DecodeMOV(Word Code)
		437	{
		438	UNUSED(Code);
		439
		440	if (ChkArgCnt(2, 2))
		441	{
		442	DecodeAdr(&ArgStr[2], MModAccB + MModReg + MModPort + MModAbs + MModIReg + MModBRel
		443	+ MModSPRel + MModRegRel + MModAccA);
		444	switch (AdrType)
		445	{
		446	case ModAccA:
		447	DecodeAdr(&ArgStr[1], MModReg + MModAbs + MModIReg + MModBRel + MModRegRel
		448	+ MModSPRel + MModAccB + MModPort + MModImm);
		449	switch (AdrType)
		450	{
		451	case ModReg:
		452	BAsmCode[0] = 0x12;
		453	BAsmCode[1] = AdrVals[0];
		454	CodeLen = 2;
		455	break;
		456	case ModAbs:
		457	BAsmCode[0] = 0x8a;
		458	memcpy(BAsmCode + 1, AdrVals, 2);
		459	CodeLen = 3;
		460	break;
		461	case ModIReg:
		462	BAsmCode[0] = 0x9a;
		463	BAsmCode[1] = AdrVals[0];
		464	CodeLen = 2;
		465	break;
		466	case ModBRel:
		467	BAsmCode[0] = 0xaa;
		468	memcpy(BAsmCode + 1, AdrVals, 2);
		469	CodeLen = 3;
		470	break;
		471	case ModRegRel:
		472	BAsmCode[0] = 0xf4;
		473	BAsmCode[1] = 0xea;
		474	memcpy(BAsmCode + 2, AdrVals, 2);
		475	CodeLen = 4;
		476	break;
		477	case ModSPRel:
		478	BAsmCode[0] = 0xf1;
		479	BAsmCode[1] = AdrVals[0];
		480	CodeLen = 2;
		481	break;
		482	case ModAccB:
		483	BAsmCode[0] = 0x62;
		484	CodeLen = 1;
		485	break;
		486	case ModPort:
		487	BAsmCode[0] = 0x80;
		488	BAsmCode[1] = AdrVals[0];
		489	CodeLen = 2;
		490	break;
		491	case ModImm:
		492	BAsmCode[0] = 0x22;
		493	BAsmCode[1] = AdrVals[0];
		494	CodeLen = 2;
		495	break;
		496	}
		497	break;
		498	case ModAccB:
		499	DecodeAdr(&ArgStr[1], MModAccA + MModReg + MModPort + MModImm);
		500	switch (AdrType)
		501	{
		502	case ModAccA:
		503	BAsmCode[0] = 0xc0;
		504	CodeLen = 1;
		505	break;
		506	case ModReg:
		507	BAsmCode[0] = 0x32;
		508	BAsmCode[1] = AdrVals[0];
		509	CodeLen = 2;
		510	break;
		511	case ModPort:
		512	BAsmCode[0] = 0x91;
		513	BAsmCode[1] = AdrVals[0];
		514	CodeLen = 2;
		515	break;
		516	case ModImm:
		517	BAsmCode[0] = 0x52;
		518	BAsmCode[1] = AdrVals[0];
		519	CodeLen = 2;
		520	break;
		521	}
		522	break;
		523	case ModReg:
		524	BAsmCode[1] = BAsmCode[2] = AdrVals[0];
		525	DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModReg + MModPort + MModImm);
		526	switch (AdrType)
		527	{
		528	case ModAccA:
		529	BAsmCode[0] = 0xd0;
		530	CodeLen = 2;
		531	break;
		532	case ModAccB:
		533	BAsmCode[0] = 0xd1;
		534	CodeLen = 2;
		535	break;
		536	case ModReg:
		537	BAsmCode[0] = 0x42;
		538	BAsmCode[1] = AdrVals[0];
		539	CodeLen = 3;
		540	break;
		541	case ModPort:
		542	BAsmCode[0] = 0xa2;
		543	BAsmCode[1] = AdrVals[0];
		544	CodeLen = 3;
		545	break;
		546	case ModImm:
		547	BAsmCode[0] = 0x72;
		548	BAsmCode[1] = AdrVals[0];
		549	CodeLen = 3;
		550	break;
		551	}
		552	break;
		553	case ModPort:
		554	BAsmCode[1] = BAsmCode[2] = AdrVals[0];
		555	DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModReg + MModImm);
		556	switch (AdrType)
		557	{
		558	case ModAccA:
		559	BAsmCode[0] = 0x21;
		560	CodeLen = 2;
		561	break;
		562	case ModAccB:
		563	BAsmCode[0] = 0x51;
		564	CodeLen = 2;
		565	break;
		566	case ModReg:
		567	BAsmCode[0] = 0x71;
		568	BAsmCode[1] = AdrVals[0];
		569	CodeLen = 3;
		570	break;
		571	case ModImm:
		572	BAsmCode[0] = 0xf7;
		573	BAsmCode[1] = AdrVals[0];
		574	CodeLen = 3;
		575	break;
		576	}
		577	break;
		578	case ModAbs:
		579	memcpy(BAsmCode + 1, AdrVals, AdrCnt);
		580	DecodeAdr(&ArgStr[1], MModAccA);
		581	if (AdrType != ModNone)
		582	{
		583	BAsmCode[0] = 0x8b;
		584	CodeLen = 3;
		585	}
		586	break;
		587	case ModIReg:
		588	BAsmCode[1] = AdrVals[0];
		589	DecodeAdr(&ArgStr[1], MModAccA);
		590	if (AdrType != ModNone)
		591	{
		592	BAsmCode[0] = 0x9b;
		593	CodeLen = 2;
		594	}
		595	break;
		596	case ModBRel:
		597	memcpy(BAsmCode + 1, AdrVals, AdrCnt);
		598	DecodeAdr(&ArgStr[1], MModAccA);
		599	if (AdrType != ModNone)
		600	{
		601	BAsmCode[0] = 0xab;
		602	CodeLen = 3;
		603	}
		604	break;
		605	case ModSPRel:
		606	BAsmCode[1] = AdrVals[0];
		607	DecodeAdr(&ArgStr[1], MModAccA);
		608	if (AdrType != ModNone)
		609	{
		610	BAsmCode[0] = 0xf2;
		611	CodeLen = 2;
		612	}
		613	break;
		614	case ModRegRel:
		615	memcpy(BAsmCode + 2, AdrVals, AdrCnt);
		616	DecodeAdr(&ArgStr[1], MModAccA);
		617	if (AdrType != ModNone)
		618	{
		619	BAsmCode[0] = 0xf4;
		620	BAsmCode[1] = 0xeb;
		621	CodeLen = 4;
		622	}
		623	break;
		624	}
		625	}
		626	}
		627
		628	static void DecodeMOVW(Word Code)
		629	{
		630	UNUSED(Code);
		631
		632	OpSize = 1;
		633	if (ChkArgCnt(2, 2))
		634	{
		635	DecodeAdr(&ArgStr[2], MModReg);
		636	if (AdrType != ModNone)
		637	{
		638	Byte AdrVal = AdrVals[0];
		639
		640	DecodeAdr(&ArgStr[1], MModReg + MModImm + MModImmBRel + MModImmRegRel);
		641	switch (AdrType)
		642	{
		643	case ModReg:
		644	BAsmCode[0] = 0x98;
		645	BAsmCode[1] = AdrVals[0];
		646	BAsmCode[2] = AdrVal;
		647	CodeLen = 3;
		648	break;
		649	case ModImm:
		650	BAsmCode[0] = 0x88;
		651	memcpy(BAsmCode + 1, AdrVals, 2);
		652	BAsmCode[3] = AdrVal;
		653	CodeLen = 4;
		654	break;
		655	case ModImmBRel:
		656	BAsmCode[0] = 0xa8;
		657	memcpy(BAsmCode + 1, AdrVals, 2);
		658	BAsmCode[3] = AdrVal;
		659	CodeLen = 4;
		660	break;
		661	case ModImmRegRel:
		662	BAsmCode[0] = 0xf4;
		663	BAsmCode[1] = 0xe8;
		664	memcpy(BAsmCode + 2, AdrVals, 2);
		665	BAsmCode[4] = AdrVal;
		666	CodeLen = 5;
		667	break;
		668	}
		669	}
		670	}
		671	}
		672
		673	static void DecodeRel8(Word Code)
		674	{
		675	if (ChkArgCnt(1, 1))
		676	{
		677	Boolean OK;
		678	tSymbolFlags Flags;
		679	Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[1], Int16, &OK, &Flags) - (EProgCounter() + 2);
		680
		681	if (OK)
		682	{
		683	if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) \|\| (AdrInt < -128))) WrError(ErrNum_JmpDistTooBig);
		684	else
		685	{
		686	CodeLen = 2;
		687	BAsmCode[0] = Code;
		688	BAsmCode[1] = AdrInt & 0xff;
		689	}
		690	}
		691	}
		692	}
		693
		694	static void DecodeCMP(Word Code)
		695	{
		696	UNUSED(Code);
		697
		698	if (ChkArgCnt(2, 2))
		699	{
		700	DecodeAdr(&ArgStr[2], MModAccA + MModAccB + MModReg);
		701	switch (AdrType)
		702	{
		703	case ModAccA:
		704	DecodeAdr(&ArgStr[1], MModAbs + MModIReg + MModBRel + MModRegRel + MModSPRel + MModAccB + MModReg + MModImm);
		705	switch (AdrType)
		706	{
		707	case ModAbs:
		708	BAsmCode[0] = 0x8d;
		709	memcpy(BAsmCode + 1, AdrVals, 2);
		710	CodeLen = 3;
		711	break;
		712	case ModIReg:
		713	BAsmCode[0] = 0x9d;
		714	BAsmCode[1] = AdrVals[0];
		715	CodeLen = 2;
		716	break;
		717	case ModBRel:
		718	BAsmCode[0] = 0xad;
		719	memcpy(BAsmCode + 1, AdrVals, 2);
		720	CodeLen = 3;
		721	break;
		722	case ModRegRel:
		723	BAsmCode[0] = 0xf4;
		724	BAsmCode[1] = 0xed;
		725	memcpy(BAsmCode + 2, AdrVals, 2);
		726	CodeLen = 4;
		727	break;
		728	case ModSPRel:
		729	BAsmCode[0] = 0xf3;
		730	BAsmCode[1] = AdrVals[0];
		731	CodeLen = 2;
		732	break;
		733	case ModAccB:
		734	BAsmCode[0] = 0x6d;
		735	CodeLen = 1;
		736	break;
		737	case ModReg:
		738	BAsmCode[0] = 0x1d;
		739	BAsmCode[1] = AdrVals[0];
		740	CodeLen = 2;
		741	break;
		742	case ModImm:
		743	BAsmCode[0] = 0x2d;
		744	BAsmCode[1] = AdrVals[0];
		745	CodeLen = 2;
		746	break;
		747	}
		748	break;
		749	case ModAccB:
		750	DecodeAdr(&ArgStr[1], MModReg + MModImm);
		751	switch (AdrType)
		752	{
		753	case ModReg:
		754	BAsmCode[0] = 0x3d;
		755	BAsmCode[1] = AdrVals[0];
		756	CodeLen = 2;
		757	break;
		758	case ModImm:
		759	BAsmCode[0] = 0x5d;
		760	BAsmCode[1] = AdrVals[0];
		761	CodeLen = 2;
		762	break;
		763	}
		764	break;
		765	case ModReg:
		766	BAsmCode[2] = AdrVals[0];
		767	DecodeAdr(&ArgStr[1], MModReg + MModImm);
		768	switch (AdrType)
		769	{
		770	case ModReg:
		771	BAsmCode[0] = 0x4d;
		772	BAsmCode[1] = AdrVals[0];
		773	CodeLen = 3;
		774	break;
		775	case ModImm:
		776	BAsmCode[0] = 0x7d;
		777	BAsmCode[1] = AdrVals[0];
		778	CodeLen = 3;
		779	break;
		780	}
		781	break;
		782	}
		783	}
		784	}
		785
		786	static void DecodeALU1(Word Code)
		787	{
		788	if (ChkArgCnt(2, 2))
		789	{
		790	DecodeAdr(&ArgStr[2], MModAccA + MModAccB + MModReg);
		791	switch (AdrType)
		792	{
		793	case ModAccA:
		794	DecodeAdr(&ArgStr[1], MModAccB + MModReg + MModImm);
		795	switch (AdrType)
		796	{
		797	case ModAccB:
		798	CodeLen = 1;
		799	BAsmCode[0] = 0x60 + Code;
		800	break;
		801	case ModReg:
		802	CodeLen = 2;
		803	BAsmCode[0] = 0x10 + Code;
		804	BAsmCode[1] = AdrVals[0];
		805	break;
		806	case ModImm:
		807	CodeLen = 2;
		808	BAsmCode[0] = 0x20 + Code;
		809	BAsmCode[1] = AdrVals[0];
		810	break;
		811	}
		812	break;
		813	case ModAccB:
		814	DecodeAdr(&ArgStr[1], MModReg + MModImm);
		815	switch (AdrType)
		816	{
		817	case ModReg:
		818	CodeLen = 2;
		819	BAsmCode[0] = 0x30 + Code;
		820	BAsmCode[1] = AdrVals[0];
		821	break;
		822	case ModImm:
		823	CodeLen = 2;
		824	BAsmCode[0] = 0x50 + Code;
		825	BAsmCode[1] = AdrVals[0];
		826	break;
		827	}
		828	break;
		829	case ModReg:
		830	BAsmCode[2] = AdrVals[0];
		831	DecodeAdr(&ArgStr[1], MModReg + MModImm);
		832	switch (AdrType)
		833	{
		834	case ModReg:
		835	CodeLen = 3;
		836	BAsmCode[0] = 0x40 + Code;
		837	BAsmCode[1] = AdrVals[0];
		838	break;
		839	case ModImm:
		840	CodeLen = 3;
		841	BAsmCode[0] = 0x70 + Code;
		842	BAsmCode[1] = AdrVals[0];
		843	break;
		844	}
		845	break;
		846	}
		847	}
		848	}
		849
		850	static void DecodeALU2(Word Code)
		851	{
		852	Boolean Rela = Hi(Code) != 0;
		853	Code &= 0xff;
		854
		855	if (ChkArgCnt(Rela ? 3 : 2, Rela ? 3 : 2))
		856	{
		857	DecodeAdr(&ArgStr[2], MModAccA + MModAccB + MModReg + MModPort);
		858	switch (AdrType)
		859	{
		860	case ModAccA:
		861	DecodeAdr(&ArgStr[1], MModAccB + MModReg + MModImm);
		862	switch (AdrType)
		863	{
		864	case ModAccB:
		865	BAsmCode[0] = 0x60 + Code;
		866	CodeLen = 1;
		867	break;
		868	case ModReg:
		869	BAsmCode[0] = 0x10 + Code;
		870	BAsmCode[1] = AdrVals[0];
		871	CodeLen = 2;
		872	break;
		873	case ModImm:
		874	BAsmCode[0] = 0x20 + Code;
		875	BAsmCode[1] = AdrVals[0];
		876	CodeLen = 2;
		877	break;
		878	}
		879	break;
		880	case ModAccB:
		881	DecodeAdr(&ArgStr[1], MModReg + MModImm);
		882	switch (AdrType)
		883	{
		884	case ModReg:
		885	BAsmCode[0] = 0x30 + Code;
		886	BAsmCode[1] = AdrVals[0];
		887	CodeLen = 2;
		888	break;
		889	case ModImm:
		890	BAsmCode[0] = 0x50 + Code;
		891	BAsmCode[1] = AdrVals[0];
		892	CodeLen = 2;
		893	break;
		894	}
		895	break;
		896	case ModReg:
		897	BAsmCode[2] = AdrVals[0];
		898	DecodeAdr(&ArgStr[1], MModReg + MModImm);
		899	switch (AdrType)
		900	{
		901	case ModReg:
		902	BAsmCode[0] = 0x40 + Code;
		903	BAsmCode[1] = AdrVals[0];
		904	CodeLen = 3;
		905	break;
		906	case ModImm:
		907	BAsmCode[0] = 0x70 + Code;
		908	BAsmCode[1] = AdrVals[0];
		909	CodeLen = 3;
		910	break;
		911	}
		912	break;
		913	case ModPort:
		914	BAsmCode[1] = AdrVals[0];
		915	DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModImm);
		916	switch (AdrType)
		917	{
		918	case ModAccA:
		919	BAsmCode[0] = 0x80 + Code;
		920	CodeLen = 2;
		921	break;
		922	case ModAccB:
		923	BAsmCode[0] = 0x90 + Code;
		924	CodeLen = 2;
		925	break;
		926	case ModImm:
		927	BAsmCode[0] = 0xa0 + Code;
		928	BAsmCode[2] = BAsmCode[1];
		929	BAsmCode[1] = AdrVals[0];
		930	CodeLen = 3;
		931	break;
		932	}
		933	break;
		934	}
		935	if ((CodeLen != 0) && (Rela))
		936	{
		937	Boolean OK;
		938	tSymbolFlags Flags;
		939	Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[3], UInt16, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
		940
		941	if (!OK)
		942	CodeLen = 0;
		943	else if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) \|\| (AdrInt < -128)))
		944	{
		945	WrError(ErrNum_JmpDistTooBig);
		946	CodeLen = 0;
		947	}
		948	else
		949	BAsmCode[CodeLen++] = AdrInt & 0xff;
		950	}
		951	}
		952	}
		953
		954	static void DecodeJmp(Word Code)
		955	{
		956	Boolean AddrRel = Hi(Code) != 0;
		957	Code &= 0xff;
		958
		959	if (ChkArgCnt(1, 1))
		960	{
		961	DecodeAdrRel(&ArgStr[1], MModAbs + MModIReg + MModBRel + MModRegRel, AddrRel);
		962	switch (AdrType)
		963	{
		964	case ModAbs:
		965	CodeLen = 3;
		966	BAsmCode[0] = 0x80 + Code;
		967	memcpy(BAsmCode + 1, AdrVals, 2);
		968	break;
		969	case ModIReg:
		970	CodeLen = 2;
		971	BAsmCode[0] = 0x90 + Code;
		972	BAsmCode[1] = AdrVals[0];
		973	break;
		974	case ModBRel:
		975	CodeLen = 3;
		976	BAsmCode[0] = 0xa0 + Code;
		977	memcpy(BAsmCode + 1, AdrVals, 2);
		978	break;
		979	case ModRegRel:
		980	CodeLen = 4;
		981	BAsmCode[0] = 0xf4;
		982	BAsmCode[1] = 0xe0 + Code;
		983	memcpy(BAsmCode + 2, AdrVals, 2);
		984	break;
		985	}
		986	}
		987	}
		988
		989	static void DecodeABReg(Word Code)
		990	{
		991	int IsDJNZ = Hi(Code) & 1;
		992	Boolean IsStack = (Code & 0x200) \|\| False;
		993
		994	Code &= 0xff;
		995
		996	if (!ChkArgCnt(1 + IsDJNZ, 1 + IsDJNZ));
		997	else if (!as_strcasecmp(ArgStr[1].str.p_str, "ST"))
		998	{
		999	if (IsStack)
		1000	{
		1001	BAsmCode[0] = 0xf3 + Code;
		1002	CodeLen = 1;
		1003	}
		1004	else
		1005	WrError(ErrNum_InvAddrMode);
		1006	}
		1007	else
		1008	{
		1009	DecodeAdr(&ArgStr[1], MModAccA + MModAccB + MModReg);
		1010	switch (AdrType)
		1011	{
		1012	case ModAccA:
		1013	BAsmCode[0] = 0xb0 + Code;
		1014	CodeLen = 1;
		1015	break;
		1016	case ModAccB:
		1017	BAsmCode[0] = 0xc0 + Code;
		1018	CodeLen = 1;
		1019	break;
		1020	case ModReg:
		1021	BAsmCode[0] = 0xd0 + Code;
		1022	BAsmCode[CodeLen + 1] = AdrVals[0];
		1023	CodeLen = 2;
		1024	break;
		1025	}
		1026	if ((IsDJNZ) && (CodeLen != 0))
		1027	{
		1028	Boolean OK;
		1029	tSymbolFlags Flags;
		1030	Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[2], Int16, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
		1031
		1032	if (!OK)
		1033	CodeLen = 0;
		1034	else if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) \|\| (AdrInt < -128)))
		1035	{
		1036	WrError(ErrNum_JmpDistTooBig);
		1037	CodeLen = 0;
		1038	}
		1039	else
		1040	BAsmCode[CodeLen++] = AdrInt & 0xff;
		1041	}
		1042	}
		1043	}
		1044
		1045	static void DecodeBit(Word Code)
		1046	{
		1047	int Rela = Hi(Code);
		1048	LongWord BitExpr;
		1049
		1050	Code &= 0xff;
		1051
		1052	if (ChkArgCnt(1 + Rela, 2 + Rela)
		1053	&& DecodeBitExpr(1, ArgCnt - Rela, &BitExpr))
		1054	{
		1055	Boolean OK;
		1056	Word Addr;
		1057	Byte Bit;
		1058
		1059	DissectBitValue(BitExpr, &Addr, &Bit);
		1060
		1061	BAsmCode[1] = 1 << Bit;
		1062	BAsmCode[2] = Lo(Addr);
		1063	switch (Hi(Addr))
		1064	{
		1065	case 0x00:
		1066	BAsmCode[0] = 0x70 + Code;
		1067	CodeLen = 3;
		1068	break;
		1069	case 0x10:
		1070	BAsmCode[0] = 0xa0 + Code;
		1071	CodeLen = 3;
		1072	break;
		1073	default:
		1074	WrStrErrorPos(ErrNum_InvAddrMode, &ArgStr[ArgCnt - 1]);
		1075	}
		1076	if ((CodeLen != 0) && Rela)
		1077	{
		1078	tSymbolFlags Flags;
		1079	Integer AdrInt = EvalStrIntExpressionWithFlags(&ArgStr[ArgCnt], Int16, &OK, &Flags) - (EProgCounter() + CodeLen + 1);
		1080
		1081	if (!OK)
		1082	CodeLen = 0;
		1083	else if (!mSymbolQuestionable(Flags) && ((AdrInt > 127) \|\| (AdrInt < -128)))
		1084	{
		1085	WrError(ErrNum_JmpDistTooBig);
		1086	CodeLen = 0;
		1087	}
		1088	else
		1089	BAsmCode[CodeLen++] = AdrInt & 0xff;
		1090	}
		1091	}
		1092	}
		1093
		1094	static void DecodeDIV(Word Code)
		1095	{
		1096	UNUSED(Code);
		1097
		1098	if (ChkArgCnt(2, 2))
		1099	{
		1100	DecodeAdr(&ArgStr[2], MModAccA);
		1101	if (AdrType != ModNone)
		1102	{
		1103	DecodeAdr(&ArgStr[1], MModReg);
		1104	if (AdrType != ModNone)
		1105	{
		1106	BAsmCode[0] = 0xf4;
		1107	BAsmCode[1] = 0xf8;
		1108	BAsmCode[2] = AdrVals[0];
		1109	CodeLen = 3;
		1110	}
		1111	}
		1112	}
		1113	}
		1114
		1115	static void DecodeINCW(Word Code)
		1116	{
		1117	UNUSED(Code);
		1118
		1119	if (ChkArgCnt(2, 2))
		1120	{
		1121	DecodeAdr(&ArgStr[2], MModReg);
		1122	if (AdrType != ModNone)
		1123	{
		1124	BAsmCode[2] = AdrVals[0];
		1125	DecodeAdr(&ArgStr[1], MModImm);
		1126	if (AdrType != ModNone)
		1127	{
		1128	BAsmCode[0] = 0x70;
		1129	BAsmCode[1] = AdrVals[0];
		1130	CodeLen = 3;
		1131	}
		1132	}
		1133	}
		1134	}
		1135
		1136	static void DecodeLDST(Word Code)
		1137	{
		1138	UNUSED(Code);
		1139
		1140	if (ChkArgCnt(1, 1))
		1141	{
		1142	DecodeAdr(&ArgStr[1], MModImm);
		1143	if (AdrType != ModNone)
		1144	{
		1145	BAsmCode[0] = 0xf0;
		1146	BAsmCode[1] = AdrVals[0];
		1147	CodeLen = 2;
		1148	}
		1149	}
		1150	}
		1151
		1152	static void DecodeTRAP(Word Code)
		1153	{
		1154	UNUSED(Code);
		1155
		1156	if (ChkArgCnt(1, 1))
		1157	{
		1158	Boolean OK;
		1159
		1160	BAsmCode[0] = EvalStrIntExpression(&ArgStr[1], Int4, &OK);
		1161	if (OK)
		1162	{
		1163	BAsmCode[0] = 0xef - BAsmCode[0];
		1164	CodeLen = 1;
		1165	}
		1166	}
		1167	}
		1168
		1169	static void DecodeTST(Word Code)
		1170	{
		1171	UNUSED(Code);
		1172
		1173	if (ChkArgCnt(1, 1))
		1174	{
		1175	DecodeAdr(&ArgStr[1], MModAccA + MModAccB);
		1176	switch (AdrType)
		1177	{
		1178	case ModAccA:
		1179	BAsmCode[0] = 0xb0;
		1180	CodeLen = 1;
		1181	break;
		1182	case ModAccB:
		1183	BAsmCode[0] = 0xc6;
		1184	CodeLen = 1;
		1185	break;
		1186	}
		1187	}
		1188	}
		1189
		1190	/****************************************************************************/
		1191
		1192	static void InitFixed(const char *NName, Word NCode)
		1193	{
		1194	AddInstTable(InstTable, NName, NCode, DecodeFixed);
		1195	}
		1196
		1197	static void InitRel8(const char *NName, Word NCode)
		1198	{
		1199	AddInstTable(InstTable, NName, NCode, DecodeRel8);
		1200	}
		1201
		1202	static void InitALU1(const char *NName, Word NCode)
		1203	{
		1204	AddInstTable(InstTable, NName, NCode, DecodeALU1);
		1205	}
		1206
		1207	static void InitALU2(const char *NName, Word NCode)
		1208	{
		1209	AddInstTable(InstTable, NName, NCode, DecodeALU2);
		1210	}
		1211
		1212	static void InitJmp(const char *NName, Word NCode)
		1213	{
		1214	AddInstTable(InstTable, NName, NCode, DecodeJmp);
		1215	}
		1216
		1217	static void InitABReg(const char *NName, Word NCode)
		1218	{
		1219	AddInstTable(InstTable, NName, NCode, DecodeABReg);
		1220	}
		1221
		1222	static void InitBit(const char *NName, Word NCode)
		1223	{
		1224	AddInstTable(InstTable, NName, NCode, DecodeBit);
		1225	}
		1226
		1227	static void InitFields(void)
		1228	{
		1229	InstTable = CreateInstTable(203);
		1230
		1231	add_null_pseudo(InstTable);
		1232
		1233	AddInstTable(InstTable, "MOV", 0, DecodeMOV);
		1234	AddInstTable(InstTable, "MOVW", 0, DecodeMOVW);
		1235	AddInstTable(InstTable, "CMP", 0, DecodeCMP);
		1236	AddInstTable(InstTable, "DIV", 0, DecodeDIV);
		1237	AddInstTable(InstTable, "INCW", 0, DecodeINCW);
		1238	AddInstTable(InstTable, "LDST", 0, DecodeLDST);
		1239	AddInstTable(InstTable, "TRAP", 0, DecodeTRAP);
		1240	AddInstTable(InstTable, "TST", 0, DecodeTST);
		1241	AddInstTable(InstTable, "DBIT", 0, DecodeDBIT);
		1242
		1243	InitFixed("CLRC" , 0x00b0); InitFixed("DINT" , 0xf000);
		1244	InitFixed("EINT" , 0xf00c); InitFixed("EINTH", 0xf004);
		1245	InitFixed("EINTL", 0xf008); InitFixed("IDLE" , 0x00f6);
		1246	InitFixed("LDSP" , 0x00fd); InitFixed("NOP" , 0x00ff);
		1247	InitFixed("RTI" , 0x00fa); InitFixed("RTS" , 0x00f9);
		1248	InitFixed("SETC" , 0x00f8); InitFixed("STSP" , 0x00fe);
		1249
		1250	InitRel8("JMP", 0x00); InitRel8("JC" , 0x03); InitRel8("JEQ", 0x02);
		1251	InitRel8("JG" , 0x0e); InitRel8("JGE", 0x0d); InitRel8("JHS", 0x0b);
		1252	InitRel8("JL" , 0x09); InitRel8("JLE", 0x0a); InitRel8("JLO", 0x0f);
		1253	InitRel8("JN" , 0x01); InitRel8("JNC", 0x07); InitRel8("JNE", 0x06);
		1254	InitRel8("JNV", 0x0c); InitRel8("JNZ", 0x06); InitRel8("JP" , 0x04);
		1255	InitRel8("JPZ", 0x05); InitRel8("JV" , 0x08); InitRel8("JZ" , 0x02);
		1256
		1257	InitALU1("ADC", 9); InitALU1("ADD", 8);
		1258	InitALU1("DAC", 14); InitALU1("DSB", 15);
		1259	InitALU1("SBB", 11); InitALU1("SUB", 10); InitALU1("MPY", 12);
		1260
		1261	InitALU2("AND" , 3); InitALU2("BTJO", 0x0106);
		1262	InitALU2("BTJZ", 0x0107); InitALU2("OR" , 4); InitALU2("XOR", 5);
		1263
		1264	InitJmp("BR" , 12); InitJmp("CALL" , 14);
		1265	InitJmp("JMPL", 0x0109); InitJmp("CALLR", 0x010f);
		1266
		1267	InitABReg("CLR" , 5); InitABReg("COMPL", 11); InitABReg("DEC" , 2);
		1268	InitABReg("INC" , 3); InitABReg("INV" , 4); InitABReg("POP" , 0x0209);
		1269	InitABReg("PUSH" , 0x0208); InitABReg("RL" , 14); InitABReg("RLC" , 15);
		1270	InitABReg("RR" , 12); InitABReg("RRC" , 13); InitABReg("SWAP" , 7);
		1271	InitABReg("XCHB" , 6); InitABReg("DJNZ" , 0x010a);
		1272
		1273	InitBit("CMPBIT", 5); InitBit("JBIT0" , 0x0107); InitBit("JBIT1" , 0x0106);
		1274	InitBit("SBIT0" , 3); InitBit("SBIT1" , 4);
		1275
		1276	AddIntelPseudo(InstTable, eIntPseudoFlag_BigEndian);
		1277	}
		1278
		1279	static void DeinitFields(void)
		1280	{
		1281	DestroyInstTable(InstTable);
		1282	}
		1283
		1284	/****************************************************************************/
		1285
		1286	static void MakeCode_370(void)
		1287	{
		1288	OpSize = 0;
		1289
		1290	if (!LookupInstTable(InstTable, OpPart.str.p_str))
		1291	WrStrErrorPos(ErrNum_UnknownInstruction, &OpPart);
		1292	}
		1293
		1294	static Boolean IsDef_370(void)
		1295	{
		1296	return (Memo("DBIT"));
		1297	}
		1298
		1299	static void InternSymbol_370(char Asc, TempResult Erg)
		1300	{
		1301	Boolean OK;
		1302	String h;
		1303	LargeInt Num;
		1304
		1305	as_tempres_set_none(Erg);
		1306	if ((strlen(Asc) < 2) \|\| ((as_toupper(Asc) != 'R') && (as_toupper(Asc) != 'P')))
		1307	return;
		1308
		1309	strcpy(h, Asc + 1);
		1310	if ((*h == '0') && (strlen(h) > 1))
		1311	*h = '$';
		1312	Num = ConstLongInt(h, &OK, 10);
		1313	if (!OK \|\| (Num < 0) \|\| (Num > 255))
		1314	return;
		1315
		1316	if (as_toupper(*Asc) == 'P')
		1317	Num += 0x1000;
		1318	as_tempres_set_int(Erg, Num);
		1319	}
		1320
		1321	static void SwitchFrom_370(void)
		1322	{
		1323	DeinitFields();
		1324	}
		1325
		1326	static void SwitchTo_370(void)
		1327	{
		1328	TurnWords = False;
		1329	SetIntConstMode(eIntConstModeIntel);
		1330
		1331	PCSymbol = "$";
		1332	HeaderID = 0x49;
		1333	NOPCode = 0xff;
		1334	DivideChars = ",";
		1335	HasAttrs = False;
		1336
		1337	ValidSegs = 1 << SegCode;
		1338	Grans[SegCode ] = 1;
		1339	ListGrans[SegCode ] = 1;
		1340	SegInits[SegCode ] = 0;
		1341	SegLimits[SegCode] = 0xffff;
		1342
		1343	MakeCode = MakeCode_370;
		1344	IsDef = IsDef_370;
		1345	SwitchFrom = SwitchFrom_370;
		1346	InternSymbol = InternSymbol_370;
		1347	DissectBit = DissectBit_370;
		1348
		1349	InitFields();
		1350	}
		1351
		1352	void code370_init(void)
		1353	{
		1354	CPU37010 = AddCPU("370C010" , SwitchTo_370);
		1355	CPU37020 = AddCPU("370C020" , SwitchTo_370);
		1356	CPU37030 = AddCPU("370C030" , SwitchTo_370);
		1357	CPU37040 = AddCPU("370C040" , SwitchTo_370);
		1358	CPU37050 = AddCPU("370C050" , SwitchTo_370);
		1359	}

Subversion Repositories pentevo

(root)//tools/asl/asl-current/code370.c – Rev 1186