WebSVN – Kolibri OS – Blame – /programs/develop/oberon07/source/MSP430RTL.ob07

Rev	Author	Line No.	Line
7983	leency	1	(*
		2	BSD 2-Clause License
		3
8859	leency	4	Copyright (c) 2019-2021, Anton Krotov
7983	leency	5	All rights reserved.
		6	*)
		7
		8	MODULE MSP430RTL;
		9
		10
		11	CONST
		12
		13	_mul* = 0;
		14	_divmod* = 1;
		15	_lsl* = 2;
		16	_asr* = 3;
		17	_ror* = 4;
		18	_lsr* = 5;
		19	_in* = 6;
		20	_in2* = 7;
		21	_set1* = 8;
		22	_incl* = 9;
		23	_excl* = 10;
		24	_move* = 11;
		25	_set* = 12;
		26	_arrcpy* = 13;
		27	_rot* = 14;
		28	_strcmp* = 15;
		29	_error* = 16;
		30	_is* = 17;
		31	_guard* = 18;
		32	_guardrec* = 19;
		33	_length* = 20;
		34	_new* = 21;
		35
		36
8859	leency	37	HP* = 15;
7983	leency	38
		39	LenIV* = 32;
		40
		41	iv = 10000H - LenIV * 2;
		42	bsl = iv - 2;
		43	sp = bsl - 2;
		44	empty_proc* = sp - 2;
8859	leency	45	bits = empty_proc - 272;
7983	leency	46	bits_offs = bits - 32;
		47	DataSize* = iv - bits_offs;
		48	types = bits_offs - 2;
		49
		50	IntVectorSize* = LenIV * 2 + DataSize;
		51
		52	VarSize* = 4;
		53
8859	leency	54	StkReserve* = 40;
7983	leency	55
8859	leency	56	trap = 2;
		57
		58
7983	leency	59	TYPE
		60
		61	EMITPROC = PROCEDURE (n: INTEGER);
		62
		63
		64	VAR
		65
8859	leency	66	ram*: INTEGER;
7983	leency	67
		68	rtl*: ARRAY 22 OF
		69	RECORD
		70	label*: INTEGER;
		71	used: BOOLEAN
		72	END;
		73
		74	Label, Word, Call: EMITPROC;
		75
		76
		77	PROCEDURE Gen*;
		78
		79
		80	PROCEDURE Word1 (word: INTEGER);
		81	BEGIN
		82	Word(word)
		83	END Word1;
		84
		85
		86	PROCEDURE Word2 (word1, word2: INTEGER);
		87	BEGIN
		88	Word1(word1);
		89	Word1(word2)
		90	END Word2;
		91
		92
		93	PROCEDURE Word3 (word1, word2, word3: INTEGER);
		94	BEGIN
		95	Word1(word1);
		96	Word1(word2);
		97	Word1(word3)
		98	END Word3;
		99
		100
		101	BEGIN
		102	(* _lsl (n, x: INTEGER): INTEGER *)
		103	IF rtl[_lsl].used THEN
		104	Label(rtl[_lsl].label);
		105	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *)
		106	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *)
		107	Word2(0F035H, 15); (* AND #15, R5 *)
		108	Word1(2400H + 3); (* JZ L1 *)
		109	(* L2: *)
		110	Word1(5404H); (* ADD R4, R4 *)
		111	Word1(8315H); (* SUB #1, R5 *)
		112	Word1(2000H + 400H - 3); (* JNZ L2 *)
		113	(* L1: *)
		114	Word1(4130H) (* RET *)
		115	END;
		116
		117	(* _asr (n, x: INTEGER): INTEGER *)
		118	IF rtl[_asr].used THEN
		119	Label(rtl[_asr].label);
		120	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *)
		121	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *)
		122	Word2(0F035H, 15); (* AND #15, R5 *)
		123	Word1(2400H + 3); (* JZ L1 *)
		124	(* L2: *)
		125	Word1(1104H); (* RRA R4 *)
		126	Word1(8315H); (* SUB #1, R5 *)
		127	Word1(2000H + 400H - 3); (* JNZ L2 *)
		128	(* L1: *)
		129	Word1(4130H) (* RET *)
		130	END;
		131
		132	(* _ror (n, x: INTEGER): INTEGER *)
		133	IF rtl[_ror].used THEN
		134	Label(rtl[_ror].label);
		135	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *)
		136	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *)
		137	Word2(0F035H, 15); (* AND #15, R5 *)
		138	Word1(2400H + 5); (* JZ L1 *)
		139	Word1(4406H); (* MOV R4, R6 *)
		140	(* L2: *)
		141	Word1(1006H); (* RRC R6 *)
		142	Word1(1004H); (* RRC R4 *)
		143	Word1(8315H); (* SUB #1, R5 *)
		144	Word1(2000H + 400H - 4); (* JNZ L2 *)
		145	(* L1: *)
		146	Word1(4130H) (* RET *)
		147	END;
		148
		149	(* _lsr (n, x: INTEGER): INTEGER *)
		150	IF rtl[_lsr].used THEN
		151	Label(rtl[_lsr].label);
		152	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- n *)
		153	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- x *)
		154	Word2(0F035H, 15); (* AND #15, R5 *)
		155	Word1(2400H + 4); (* JZ L1 *)
		156	(* L2: *)
		157	Word1(0C312H); (* BIC #1, SR *)
		158	Word1(1004H); (* RRC R4 *)
		159	Word1(8315H); (* SUB #1, R5 *)
		160	Word1(2000H + 400H - 4); (* JNZ L2 *)
		161	(* L1: *)
		162	Word1(4130H) (* RET *)
		163	END;
		164
		165	(* _set (b, a: INTEGER): SET *)
		166	IF rtl[_set].used THEN
		167	Label(rtl[_set].label);
		168	Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- b *)
		169	Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- a *)
		170	Word1(9504H); (* CMP R5, R4 *)
		171	Word1(3800H + 24); (* JL L1 *)
		172	Word2(9035H, 16); (* CMP #16, R5 *)
		173	Word1(3400H + 21); (* JGE L1 *)
		174	Word1(9304H); (* CMP #0, R4 *)
		175	Word1(3800H + 19); (* JL L1 *)
		176	Word2(9034H, 16); (* CMP #16, R4 *)
		177	Word1(3800H + 2); (* JL L2 *)
		178	Word2(4034H, 15); (* MOV #15, R4 *)
		179	(* L2: *)
		180	Word1(9305H); (* CMP #0, R5 *)
		181	Word1(3400H + 1); (* JGE L3 *)
		182	Word1(4305H); (* MOV #0, R5 *)
		183	(* L3: *)
		184	Word1(8504H); (* SUB R5, R4 *)
		185	Word1(5404H); (* ADD R4, R4 *)
		186	Word2(5034H, bits_offs); (* ADD bits_offs, R4 *)
		187	Word1(4424H); (* MOV @R4, R4 *)
		188	Word1(5505H); (* ADD R5, R5 *)
		189	Word1(5405H); (* ADD R4, R5 *)
		190	Word2(5035H, bits); (* ADD bits, R5 *)
		191	Word1(4524H); (* MOV @R5, R4 *)
8859	leency	192	Word1(4130H); (* RET *)
7983	leency	193	(* L1: *)
		194	Word1(4304H); (* MOV #0, R4 *)
		195	Word1(4130H) (* RET *)
		196	END;
		197
		198	(* _set1 (a: INTEGER): SET *)
		199	IF rtl[_set1].used THEN
		200	Label(rtl[_set1].label);
		201	Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- a *)
		202	Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *)
		203	Word1(2000H + 5); (* JNZ L1 *)
		204	Word1(5404H); (* ADD R4, R4 *)
		205	Word2(5034H, bits); (* ADD bits, R4 *)
		206	Word1(4424H); (* MOV @R4, R4 *)
8859	leency	207	Word1(4130H); (* RET *)
7983	leency	208	(* L1: *)
		209	Word1(4304H); (* MOV #0, R4 *)
		210	Word1(4130H) (* RET *)
		211	END;
		212
		213	(* _in2 (i, s: INTEGER): BOOLEAN *)
		214	IF rtl[_in2].used THEN
		215	Label(rtl[_in2].label);
		216	Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- i *)
		217	Word1(5404H); (* ADD R4, R4 *)
		218	Word2(5034H, bits); (* ADD bits, R4 *)
		219	Word1(4424H); (* MOV @R4, R4 *)
		220	Word2(0F114H, 4); (* AND 4(SP), R4 *)
		221	Word1(2400H + 1); (* JZ L1 *)
		222	Word1(4314H); (* MOV #1, R4 *)
		223	(* L1: *)
		224	Word1(4130H) (* RET *)
		225	END;
		226
		227	(* _in (s, i: INTEGER): BOOLEAN *)
		228	IF rtl[_in].used THEN
		229	Label(rtl[_in].label);
		230	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- i *)
		231	Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *)
		232	Word1(2000H + 9); (* JNZ L2 *)
		233	Word1(5404H); (* ADD R4, R4 *)
		234	Word2(5034H, bits); (* ADD bits, R4 *)
		235	Word1(4424H); (* MOV @R4, R4 *)
		236	Word2(0F114H, 2); (* AND 2(SP), R4 *)
		237	Word1(2400H + 3); (* JZ L1 *)
		238	Word1(4314H); (* MOV #1, R4 *)
8859	leency	239	Word1(4130H); (* RET *)
7983	leency	240	(* L2: *)
		241	Word1(4304H); (* MOV #0, R4 *)
		242	(* L1: *)
		243	Word1(4130H) (* RET *)
		244	END;
		245
		246	(* _incl (VAR s: SET; i: INTEGER) *)
		247	IF rtl[_incl].used THEN
		248	Label(rtl[_incl].label);
		249	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- i *)
		250	Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *)
		251	Word1(2000H + 8); (* JNZ L1 *)
		252	Word1(5404H); (* ADD R4, R4 *)
		253	Word2(5034H, bits); (* ADD bits, R4 *)
		254	Word1(4424H); (* MOV @R4, R4 *)
		255	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- @s *)
		256	Word2(0D485H, 0); (* BIS R4, 0(R5) *)
		257	(* L1: *)
		258	Word1(4130H) (* RET *)
		259	END;
		260
		261	(* _excl (VAR s: SET; i: INTEGER) *)
		262	IF rtl[_excl].used THEN
		263	Label(rtl[_excl].label);
		264	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- i *)
		265	Word2(0B034H, 0FFF0H); (* BIT #0FFF0H, R4 *)
		266	Word1(2000H + 8); (* JNZ L1 *)
		267	Word1(5404H); (* ADD R4, R4 *)
		268	Word2(5034H, bits); (* ADD bits, R4 *)
		269	Word1(4424H); (* MOV @R4, R4 *)
		270	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- @s *)
		271	Word2(0C485H, 0); (* BIC R4, 0(R5) *)
		272	(* L1: *)
		273	Word1(4130H) (* RET *)
		274	END;
		275
		276	(* _rot (len, adr: INTEGER) *)
		277	IF rtl[_rot].used THEN
		278	Label(rtl[_rot].label);
		279	Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- len *)
		280	Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- adr *)
		281	Word1(8314H); (* SUB #1, R4 *)
		282	Word1(5404H); (* ADD R4, R4 *)
		283	Word1(1225H); (* PUSH @R5 *)
		284	Word1(4406H); (* MOV R4, R6 *)
		285	(* L1: *)
		286	Word3(4595H, 2, 0); (* MOV 2(R5), 0(R5) *)
		287	Word1(5325H); (* ADD #2, R5 *)
		288	Word1(8326H); (* SUB #2, R6 *)
		289	Word1(2000H + 400H - 6); (* JNZ L1 *)
		290	Word2(41B5H, 0); (* MOV @SP+, 0(R5) *)
		291	Word1(4130H) (* RET *)
		292	END;
		293
		294	(* _divmod (b, a: INTEGER): INTEGER (* res -> R4, mod -> R5 ) )
		295	IF rtl[_divmod].used THEN
		296	Label(rtl[_divmod].label);
		297	Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- a *)
		298	Word1(4304H); (* MOV #0, R4 *)
		299	(* L1: *)
		300	Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- b *)
		301	Word1(9605H); (* CMP R6, R5 *)
		302	Word1(3800H + 17); (* JL L3 *)
		303	Word1(4327H); (* MOV #2, R7 *)
		304	Word1(5606H); (* ADD R6, R6 *)
		305	(* L4: *)
		306	Word1(9306H); (* CMP #0, R6 *)
		307	Word1(2400H + 6); (* JZ L2 *)
		308	Word1(3800H + 5); (* JL L2 *)
		309	Word1(9605H); (* CMP R6, R5 *)
		310	Word1(3800H + 3); (* JL L2 *)
		311	Word1(5606H); (* ADD R6, R6 *)
		312	Word1(5707H); (* ADD R7, R7 *)
		313	Word1(3C00H + 400H - 8); (* JMP L4 *)
		314	(* L2: *)
		315	Word1(0C312H); (* BIC #1, SR *)
		316	Word1(1006H); (* RRC R6 *)
		317	Word1(0C312H); (* BIC #1, SR *)
		318	Word1(1007H); (* RRC R7 *)
		319	Word1(8605H); (* SUB R6, R5 *)
		320	Word1(5704H); (* ADD R7, R4 *)
		321	Word1(3C00H + 400H - 21); (* JMP L1 *)
		322	(* L3: *)
		323	(----------- (a < 0) --------------)
		324	(* L1: *)
		325	Word1(9305H); (* CMP #0, R5 *)
		326	Word1(3400H + 23); (* JGE L3 *)
		327	Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- b *)
		328	Word1(4327H); (* MOV #2, R7 *)
		329	Word1(5606H); (* ADD R6, R6 *)
		330	Word1(0E335H); (* XOR #-1, R5 *)
		331	Word1(5315H); (* ADD #1, R5 *)
		332	(* L4: *)
		333	Word1(9306H); (* CMP #0, R6 *)
		334	Word1(2400H + 6); (* JZ L2 *)
		335	Word1(3800H + 5); (* JL L2 *)
		336	Word1(9605H); (* CMP R6, R5 *)
		337	Word1(3800H + 3); (* JL L2 *)
		338	Word1(5606H); (* ADD R6, R6 *)
		339	Word1(5707H); (* ADD R7, R7 *)
		340	Word1(3C00H + 400H - 8); (* JMP L4 *)
		341	(* L2: *)
		342	Word1(0E335H); (* XOR #-1, R5 *)
		343	Word1(5315H); (* ADD #1, R5 *)
		344	Word1(0C312H); (* BIC #1, SR *)
		345	Word1(1006H); (* RRC R6 *)
		346	Word1(0C312H); (* BIC #1, SR *)
		347	Word1(1007H); (* RRC R7 *)
		348	Word1(5605H); (* ADD R6, R5 *)
		349	Word1(8704H); (* SUB R7, R4 *)
		350	Word1(3C00H + 400H - 25); (* JMP L1 *)
		351	(* L3: *)
		352	Word1(4130H) (* RET *)
		353	END;
		354
		355	(* _mul (a, b: INTEGER): INTEGER *)
		356	IF rtl[_mul].used THEN
		357	Label(rtl[_mul].label);
		358	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- a *)
		359	Word2(4116H, 4); (* MOV 4(SP), R6; R6 <- b *)
		360	Word1(4304H); (* MOV #0, R4; res := 0 *)
		361	Word1(9306H); (* CMP #0, R6 *)
		362	Word1(2400H + 7); (* JZ L1 *)
		363	(* L2: *)
		364	Word1(0B316H); (* BIT #1, R6 *)
		365	Word1(2400H + 1); (* JZ L3 *)
		366	Word1(5504H); (* ADD R5, R4 *)
		367	(* L3: *)
		368	Word1(5505H); (* ADD R5, R5 *)
		369	Word1(0C312H); (* BIC #1, SR *)
		370	Word1(1006H); (* RRC R6 *)
		371	Word1(2000H + 400H - 7); (* JNZ L2 *)
		372	(* L1: *)
		373	Word1(4130H) (* RET *)
		374	END;
		375
		376	(* _error (modNum, modName, err, line: INTEGER) *)
		377	IF rtl[_error].used THEN
		378	Label(rtl[_error].label);
8859	leency	379	Word1(5321H); (* ADD #2, SP *)
		380	Word1(4134H); (* POP R4; R4 <- modNum *)
		381	Word1(4135H); (* POP R5; R5 <- modName *)
		382	Word1(4136H); (* POP R6; R6 <- err *)
		383	Word1(4137H); (* POP R7; R7 <- line *)
		384	Word2(4211H, sp); (* MOV sp(SR), SP *)
		385	Word1(1207H); (* PUSH R7 *)
		386	Word1(1206H); (* PUSH R6 *)
		387	Word1(1205H); (* PUSH R5 *)
		388	Word1(1204H); (* PUSH R4 *)
		389	Word2(4214H, sp); (* MOV sp(SR), R4 *)
		390	Word2(1294H, trap); (* CALL trap(R4) *)
		391	Word2(04032H, 0F0H) (* MOV CPUOFF+OSCOFF+SCG0+SCG1, SR *)
7983	leency	392	END;
		393
		394	(* _new (t, size: INTEGER; VAR ptr: INTEGER) *)
		395	IF rtl[_new].used THEN
		396	Label(rtl[_new].label);
8859	leency	397	Word1(1202H); (* PUSH SR *)
		398	Word1(4302H); (* MOV #0, SR *)
		399	Word1(4303H); (* NOP *)
		400	Word1(4104H); (* MOV SP, R4 *)
		401	Word2(8034H, StkReserve); (* SUB #StkReserve, R4 *)
		402	Word1(4005H + 100H * HP); (* MOV HP, R5 *)
		403	Word2(5115H, 6); (* ADD 6(SP), R5 *)
		404	Word1(9504H); (* CMP R5, R4 *)
		405	Word2(4114H, 8); (* MOV 8(SP), R4 *)
		406	Word1(3800H + 12); (* JL L1 *)
		407	Word3(4190H + HP, 4, 0); (* MOV 4(SP), 0(HP) *)
		408	Word1(5320H + HP); (* ADD #2, HP *)
		409	Word2(4084H + 100H * HP, 0); (* MOV HP, 0(R4) *)
		410	(* L3 *)
		411	Word2(4380H + HP, 0); (* MOV #0, 0(HP) *)
		412	Word1(5320H + HP); (* ADD #2, HP *)
		413	Word1(9500H + HP); (* CMP R5, HP *)
		414	Word1(3800H + 400H - 5); (* JL L3 *)
		415	Word1(3C00H + 2); (* JMP L2 *)
		416	(* L1 *)
		417	Word2(4384H, 0); (* MOV #0, 0(R4) *)
		418	(* L2 *)
		419	Word1(1300H) (* RETI *)
7983	leency	420	END;
		421
		422	(* _guardrec (t0, t1: INTEGER): INTEGER *)
		423	IF rtl[_guardrec].used THEN
		424	Label(rtl[_guardrec].label);
		425	Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- t0 *)
		426	Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- t1 *)
		427	Word2(4036H, types); (* MOV #types, R6 *)
		428	(* L3: *)
		429	Word1(9305H); (* CMP #0, R5 *)
		430	Word1(2400H + 8); (* JZ L1 *)
		431	Word1(9405H); (* CMP R4, R5 *)
		432	Word1(2400H + 10); (* JZ L2 *)
		433	Word1(5505H); (* ADD R5, R5 *)
		434	Word1(0E335H); (* XOR #-1, R5 *)
		435	Word1(5315H); (* ADD #1, R5 *)
		436	Word1(5605H); (* ADD R6, R5 *)
		437	Word1(4525H); (* MOV @R5, R5 *)
		438	Word1(3C00H + 400H - 10); (* JMP L3 *)
		439	(* L1: *)
		440	Word1(9405H); (* CMP R4, R5 *)
		441	Word1(2400H + 2); (* JZ L2 *)
		442	Word1(4304H); (* MOV #0, R4 *)
8859	leency	443	Word1(4130H); (* RET *)
7983	leency	444	(* L2: *)
		445	Word1(4314H); (* MOV #1, R4 *)
		446	Word1(4130H) (* RET *)
		447	END;
		448
		449	(* _is (t, p: INTEGER): INTEGER *)
		450	IF rtl[_is].used THEN
		451	Label(rtl[_is].label);
		452	Word2(4114H, 4); (* MOV 4(SP), R4; R4 <- p *)
		453	Word2(4115H, 2); (* MOV 2(SP), R5; R5 <- t *)
		454	Word1(9304H); (* TST R4 *)
		455	Word1(2400H + 2); (* JZ L *)
		456	Word2(4414H, -2); (* MOV -2(R4), R4 *)
		457	(* L: *)
		458	Word1(1204H); (* PUSH R4 *)
		459	Word1(1205H); (* PUSH R5 *)
		460	Call(rtl[_guardrec].label); (* CALL _guardrec *)
		461	Word1(5221H); (* ADD #4, SP *)
		462	Word1(4130H) (* RET *)
		463	END;
		464
		465	(* _guard (t, p: INTEGER): INTEGER *)
		466	IF rtl[_guard].used THEN
		467	Label(rtl[_guard].label);
		468	Word2(4115H, 4); (* MOV 4(SP), R5; R5 <- p *)
		469	Word1(4314H); (* MOV #1, R4 *)
		470	Word1(4525H); (* MOV @R5, R5 *)
		471	Word1(9305H); (* TST R5 *)
		472	Word1(2400H + 9); (* JZ L *)
		473	Word2(4515H, -2); (* MOV -2(R5), R5 *)
		474	Word2(4114H, 2); (* MOV 2(SP), R4; R4 <- t *)
		475	Word1(1205H); (* PUSH R5 *)
		476	Word1(1204H); (* PUSH R4 *)
		477	Call(rtl[_guardrec].label); (* CALL _guardrec *)
		478	Word1(5221H); (* ADD #4, SP *)
		479	(* L: *)
		480	Word1(4130H) (* RET *)
		481	END;
		482
		483	(* _move (bytes, dest, source: INTEGER) *)
		484	IF rtl[_move].used THEN
		485	Label(rtl[_move].label);
		486	Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- bytes *)
		487	Word2(4117H, 4); (* MOV 4(SP), R7; R7 <- dest *)
		488	Word2(4115H, 6); (* MOV 6(SP), R5; R5 <- source *)
		489	Word1(9306H); (* CMP #0, R6 *)
		490	Word1(3800H + 6); (* JL L1 *)
		491	Word1(2400H + 5); (* JZ L1 *)
		492	(* L2: *)
		493	Word2(45F7H, 0); (* MOV.B @R5+, 0(R7) *)
		494	Word1(5317H); (* ADD #1, R7 *)
		495	Word1(8316H); (* SUB #1, R6 *)
		496	Word1(2000H + 400H - 5); (* JNZ L2 *)
		497	(* L1: *)
		498	Word1(4130H) (* RET *)
		499	END;
		500
		501	(* _arrcpy (base_size, len_dst, dst, len_src, src: INTEGER) *)
		502	IF rtl[_arrcpy].used THEN
		503	Label(rtl[_arrcpy].label);
		504	Word3(9191H, 8, 4); (* CMP 8(SP), 4(SP) *)
		505	Word1(3800H + 18); (* JL L1 *)
		506	Word2(1211H, 12); (* PUSH 12(SP) *)
		507	Word2(1211H, 10); (* PUSH 10(SP) *)
		508	Word2(1211H, 14); (* PUSH 14(SP) *)
		509	Word2(1211H, 10); (* PUSH 10(SP) *)
		510	Call(rtl[_mul].label); (* CALL _mul *)
		511	Word1(5221H); (* ADD #4, SP *)
		512	Word1(1204H); (* PUSH R4 *)
		513	Call(rtl[_move].label); (* CALL _move *)
		514	Word2(5031H, 6); (* ADD #6, SP *)
		515	Word1(4314H); (* MOV #1, R4 *)
		516	Word1(4130H); (* RET *)
		517	(* L1 *)
		518	Word1(4304H); (* MOV #0, R4 *)
		519	Word1(4130H) (* RET *)
		520	END;
		521
		522	(* _length (len, str: INTEGER): INTEGER *)
		523	IF rtl[_length].used THEN
		524	Label(rtl[_length].label);
		525	Word2(4116H, 2); (* MOV 2(SP), R6; R6 <- len *)
		526	Word2(4117H, 4); (* MOV 4(SP), R7; R7 <- str *)
		527	Word1(4304H); (* MOV #0, R4; res := 0 *)
		528	(* L2: *)
		529	Word1(4775H); (* MOV.B @R7+, R5 *)
		530	Word1(9305H); (* CMP #0, R5 *)
		531	Word1(2400H + 3); (* JZ L1 *)
		532	Word1(5314H); (* ADD #1, R4 *)
		533	Word1(8316H); (* SUB #1, R6 *)
		534	Word1(2000H + 400H - 6); (* JNZ L2 *)
		535	(* L1: *)
		536	Word1(4130H) (* RET *)
		537	END;
		538
		539	(* _strcmp (op, len2, str2, len1, str1: INTEGER): BOOLEAN *)
		540	IF rtl[_strcmp].used THEN
		541	Label(rtl[_strcmp].label);
		542	Word2(4116H, 4); (* MOV 4(SP), R6; R6 <- len2 *)
		543	Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- len1 *)
		544	Word1(9607H); (* CMP R6, R7 *)
		545	Word1(3400H + 1); (* JGE L5 *)
		546	Word1(4706H); (* MOV R7, R6 *)
		547	(* L5: *)
		548	Word1(1206H); (* PUSH R6 *)
		549	Word2(4116H, 12); (* MOV 12(SP), R6; R6 <- str1 *)
		550	Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- str2 *)
		551	(* L3: *)
		552	Word2(9381H, 0); (* CMP #0, 0(SP) *)
		553	Word1(2400H + 11); (* JZ L1 *)
		554	Word1(4674H); (* MOV.B @R6+, R4 *)
		555	Word1(4775H); (* MOV.B @R7+, R5 *)
		556	Word2(8391H, 0); (* SUB #1, 0(SP) *)
		557	Word1(9405H); (* CMP R4, R5 *)
		558	Word1(2400H + 2); (* JZ L2 *)
		559	Word1(8504H); (* SUB R5, R4 *)
		560	Word1(3C00H + 5); (* JMP L4 *)
		561	(* L2: *)
		562	Word1(9304H); (* CMP #0, R4 *)
		563	Word1(2000H + 400H - 13); (* JNZ L3 *)
		564	Word1(3C00H + 2); (* JMP L4 *)
		565	(* L1: *)
		566	Word2(4034H, 8000H); (* MOV #8000H, R4 *)
		567	(* L4: *)
		568	Word1(5321H); (* ADD #2, SP *)
		569
		570	Word2(9034H, 8000H); (* CMP #8000H, R4 *)
		571	Word1(2000H + 18); (* JNZ L6 *)
		572	Word2(4116H, 4); (* MOV 4(SP), R6; R6 <- len2 *)
		573	Word2(4117H, 8); (* MOV 8(SP), R7; R7 <- len1 *)
		574	Word1(9607H); (* CMP R6, R7 *)
		575	Word1(2400H + 11); (* JZ L7 *)
		576	Word1(3800H + 4); (* JL L8 *)
		577	Word2(5116H, 10); (* ADD 10(SP), R6 *)
		578	Word1(4664H); (* MOV.B @R6, R4 *)
		579	Word1(3C00H + 7); (* JMP L6 *)
		580	(* L8: *)
		581	Word2(5117H, 6); (* ADD 6(SP), R7 *)
		582	Word1(4764H); (* MOV.B @R7, R4 *)
		583	Word1(0E334H); (* XOR #-1, R4 *)
		584	Word1(5314H); (* ADD #1, R4 *)
		585	Word1(3C00H + 1); (* JMP L6 *)
		586	(* L7: *)
		587	Word1(4304H); (* MOV #0, R4 *)
		588	(* L6: *)
		589
		590	Word2(5110H, 2); (* ADD 2(SP), PC; PC <- PC + op *)
		591
		592	Word1(9304H); (* CMP #0, R4 *)
		593	Word1(4314H); (* MOV #1, R4 *)
		594	Word1(2400H + 1); (* JZ L *)
		595	Word1(4304H); (* MOV #0, R4 *)
		596	(* L *)
		597	Word1(4130H); (* RET *)
		598	Word1(4303H); (* NOP *)
		599
		600	Word1(9304H); (* CMP #0, R4 *)
		601	Word1(4314H); (* MOV #1, R4 *)
		602	Word1(2000H + 1); (* JNZ L *)
		603	Word1(4304H); (* MOV #0, R4 *)
		604	(* L *)
		605	Word1(4130H); (* RET *)
		606	Word1(4303H); (* NOP *)
		607
		608	Word1(9304H); (* CMP #0, R4 *)
		609	Word1(4314H); (* MOV #1, R4 *)
		610	Word1(3800H + 1); (* JL L *)
		611	Word1(4304H); (* MOV #0, R4 *)
		612	(* L *)
		613	Word1(4130H); (* RET *)
		614	Word1(4303H); (* NOP *)
		615
		616	Word1(9304H); (* CMP #0, R4 *)
		617	Word1(4314H); (* MOV #1, R4 *)
		618	Word1(3800H + 2); (* JL L *)
		619	Word1(2400H + 1); (* JZ L *)
		620	Word1(4304H); (* MOV #0, R4 *)
		621	(* L *)
		622	Word1(4130H); (* RET *)
		623
		624	Word1(9304H); (* CMP #0, R4 *)
		625	Word1(4304H); (* MOV #0, R4 *)
		626	Word1(3800H + 2); (* JL L *)
		627	Word1(2400H + 1); (* JZ L *)
		628	Word1(4314H); (* MOV #1, R4 *)
		629	(* L *)
		630	Word1(4130H); (* RET *)
		631
		632	Word1(9304H); (* CMP #0, R4 *)
		633	Word1(4314H); (* MOV #1, R4 *)
		634	Word1(3400H + 1); (* JGE L *)
		635	Word1(4304H); (* MOV #0, R4 *)
		636	(* L *)
		637	Word1(4130H) (* RET *)
		638	END
		639
		640	END Gen;
		641
		642
		643	PROCEDURE Set* (idx, label: INTEGER);
		644	BEGIN
		645	rtl[idx].label := label;
		646	rtl[idx].used := FALSE
		647	END Set;
		648
		649
		650	PROCEDURE Used* (idx: INTEGER);
		651	BEGIN
		652	rtl[idx].used := TRUE;
		653	IF (idx = _guard) OR (idx = _is) THEN
		654	rtl[_guardrec].used := TRUE
		655	ELSIF idx = _arrcpy THEN
		656	rtl[_move].used := TRUE;
		657	rtl[_mul].used := TRUE
		658	END
		659	END Used;
		660
		661
8859	leency	662	PROCEDURE Init* (pLabel, pWord, pCall: EMITPROC);
7983	leency	663	BEGIN
		664	Label := pLabel;
		665	Word := pWord;
		666	Call := pCall;
		667	ram := 200H;
		668	END Init;
		669
		670
		671	END MSP430RTL.

Subversion Repositories Kolibri OS

(root)/programs/develop/oberon07/source/MSP430RTL.ob07 – Rev 8859