/programs/develop/cedit/SRC/Icons.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2021, 2022 Anton Krotov |
Copyright 2021-2023 Anton Krotov |
This file is part of CEdit. |
58,14 → 58,14 |
PROCEDURE GetImg (ptr, size: INTEGER): INTEGER; |
VAR |
image_data, dst, x, type: INTEGER; |
image_data, dst, x, Type: INTEGER; |
BEGIN |
image_data := img_decode(ptr, size, 0); |
IF image_data # 0 THEN |
SYSTEM.GET(image_data + 4, x); |
ASSERT(x = SIZE); |
SYSTEM.GET(image_data + 20, type); |
IF type # 3 THEN |
SYSTEM.GET(image_data + 20, Type); |
IF Type # 3 THEN |
dst := img_convert(image_data, 0, 3, 0, 0); |
img_destroy(image_data); |
image_data := dst |
/programs/develop/oberon07/Compiler.kex |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
/programs/develop/oberon07/LICENSE |
---|
1,6 → 1,6 |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
Redistribution and use in source and binary forms, with or without |
/programs/develop/oberon07/doc/WinLib.txt |
---|
File deleted |
\ No newline at end of file |
/programs/develop/oberon07/doc/x86_64.txt |
---|
File deleted |
\ No newline at end of file |
/programs/develop/oberon07/doc/x86.txt |
---|
28,7 → 28,9 |
исходном коде), по умолчанию - 4 |
-nochk <"ptibcwra"> отключить проверки при выполнении (см. ниже) |
-lower разрешить ключевые слова и встроенные идентификаторы в |
нижнем регистре |
нижнем регистре (по умолчанию) |
-upper только верхний регистр для ключевых слов и встроенных |
идентификаторов |
-def <имя> задать символ условной компиляции |
-ver <major.minor> версия программы (только для kosdll) |
-uses вывести список импортированных модулей |
81,6 → 83,7 |
13. Возможен импорт модулей с указанием пути и имени файла |
14. Добавлен специальный синтаксис для условной компиляции (см. CC.txt) |
15. Имя процедуры в конце объявления (после END) необязательно |
16. Разрешено использовать нижний регистр для ключевых слов |
------------------------------------------------------------------------------ |
Особенности реализации |
137,6 → 140,10 |
PROCEDURE WSADR(x: строковая константа (WCHAR)): INTEGER |
возвращает адрес x |
PROCEDURE VAL(v: любой тип; T): T |
v - переменная; |
интерпретирует v, как переменную типа T |
PROCEDURE SIZE(T): INTEGER |
возвращает размер типа T |
/programs/develop/oberon07/lib/KolibriOS/Math.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2013-2014, 2018-2020 Anton Krotov |
Copyright (c) 2013-2014, 2018-2022 Anton Krotov |
All rights reserved. |
*) |
271,8 → 271,7 |
ELSIF x < -15.0 THEN |
x := -1.0 |
ELSE |
x := exp(2.0 * x); |
x := (x - 1.0) / (x + 1.0) |
x := 1.0 - 2.0 / (exp(2.0 * x) + 1.0) |
END |
RETURN x |
/programs/develop/oberon07/source/AMD64.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
*) |
1152,14 → 1152,13 |
movrm(reg1, reg1, 0) |
|IL.opPARAM: |
n := param2; |
IF n = 1 THEN |
IF param2 = 1 THEN |
UnOp(reg1); |
push(reg1); |
drop |
ELSE |
ASSERT(R.top + 1 <= n); |
PushAll(n) |
ASSERT(R.top + 1 <= param2); |
PushAll(param2) |
END |
|IL.opJNZ1: |
1344,8 → 1343,8 |
|IL.opNEW: |
PushAll(1); |
n := param2 + 8; |
ASSERT(UTILS.Align(n, 8)); |
n := param2 + 16; |
ASSERT(UTILS.Align(n, 16)); |
pushc(n); |
pushc(param1); |
CallRTL(IL._new) |
1787,11 → 1786,6 |
X86._movrm(reg1, reg1, 0, param2 * 8, FALSE); |
X86._movrm(reg1, reg2, 0, param2 * 8, TRUE) |
|IL.opCHKBYTE: |
BinOp(reg1, reg2); |
cmprc(reg1, 256); |
jcc(jb, param1) |
|IL.opCHKIDX: |
UnOp(reg1); |
cmprc(reg1, param2); |
1832,14 → 1826,6 |
INCL(R.regs, reg1); |
ASSERT(REG.GetReg(R, reg1)) |
|IL.opCHR: |
UnOp(reg1); |
andrc(reg1, 255) |
|IL.opWCHR: |
UnOp(reg1); |
andrc(reg1, 65535) |
|IL.opEQP, IL.opNEP, IL.opEQIP, IL.opNEIP: |
UnOp(reg1); |
reg2 := GetAnyReg(); |
2385,6 → 2371,7 |
BEGIN |
Xmm[0] := 0; |
X86.align16(TRUE); |
tcount := CHL.Length(IL.codes.types); |
Win64RegPar[0] := rcx; |
/programs/develop/oberon07/source/ARITH.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2021, Anton Krotov |
Copyright (c) 2018-2022, Anton Krotov |
All rights reserved. |
*) |
217,7 → 217,6 |
PROCEDURE fconv* (s: ARRAY OF CHAR; VAR v: VALUE; VAR error: INTEGER); |
VAR |
value: REAL; |
frac: REAL; |
exp10: REAL; |
i, n, d: INTEGER; |
minus: BOOLEAN; |
225,32 → 224,24 |
BEGIN |
error := 0; |
value := 0.0; |
frac := 0.0; |
exp10 := 1.0; |
minus := FALSE; |
n := 0; |
i := 0; |
WHILE (error = 0) & STRINGS.digit(s[i]) DO |
IF opFloat2(value, 10.0, "*") & opFloat2(value, FLT(digit[ORD(s[i])]), "+") THEN |
exp10 := 0.0; |
WHILE (error = 0) & (STRINGS.digit(s[i]) OR (s[i] = ".")) DO |
IF s[i] = "." THEN |
exp10 := 1.0; |
INC(i) |
ELSE |
error := 4 |
END |
END; |
INC(i); |
WHILE (error = 0) & STRINGS.digit(s[i]) DO |
IF opFloat2(frac, 10.0, "*") & opFloat2(frac, FLT(digit[ORD(s[i])]), "+") THEN |
exp10 := exp10 * 10.0; |
IF opFloat2(value, 10.0, "*") & opFloat2(value, FLT(digit[ORD(s[i])]), "+") & opFloat2(exp10, 10.0, "*") THEN |
INC(i) |
ELSE |
error := 4 |
END |
END |
END; |
IF ~opFloat2(value, frac / exp10, "+") THEN |
IF ~opFloat2(value, exp10, "/") THEN |
error := 4 |
END; |
/programs/develop/oberon07/source/Compiler.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
*) |
48,6 → 48,7 |
BEGIN |
options.lower := TRUE; |
out := ""; |
checking := options.checking; |
_end := FALSE; |
133,6 → 134,9 |
ELSIF param = "-lower" THEN |
options.lower := TRUE |
ELSIF param = "-upper" THEN |
options.lower := FALSE |
ELSIF param = "-pic" THEN |
options.pic := TRUE |
215,7 → 219,7 |
C.Ln; |
C.String("Akron Oberon Compiler v"); C.Int(UTILS.vMajor); C.String("."); C.Int2(UTILS.vMinor); |
C.String(" ("); C.Int(UTILS.bit_depth); C.StringLn("-bit) " + UTILS.Date); |
C.StringLn("Copyright (c) 2018-2022, Anton Krotov"); |
C.StringLn("Copyright (c) 2018-2023, Anton Krotov"); |
IF inname = "" THEN |
C.Ln; |
243,7 → 247,8 |
C.StringLn(" -stk <size> set size of stack in Mbytes (Windows, Linux, KolibriOS)"); C.Ln; |
C.StringLn(" -nochk <'ptibcwra'> disable runtime checking (pointers, types, indexes,"); |
C.StringLn(" BYTE, CHR, WCHR)"); C.Ln; |
C.StringLn(" -lower allow lower case for keywords"); C.Ln; |
C.StringLn(" -lower allow lower case for keywords (default)"); C.Ln; |
C.StringLn(" -upper only upper case for keywords"); C.Ln; |
C.StringLn(" -def <identifier> define conditional compilation symbol"); C.Ln; |
C.StringLn(" -ver <major.minor> set version of program (KolibriOS DLL)"); C.Ln; |
C.StringLn(" -ram <size> set size of RAM in bytes (MSP430) or Kbytes (STM32)"); C.Ln; |
/programs/develop/oberon07/source/FILES.ob07 |
---|
1,13 → 1,13 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2021, Anton Krotov |
Copyright (c) 2018-2022, Anton Krotov |
All rights reserved. |
*) |
MODULE FILES; |
IMPORT UTILS, C := COLLECTIONS, CONSOLE; |
IMPORT UTILS, C := COLLECTIONS; |
TYPE |
/programs/develop/oberon07/source/IL.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
*) |
24,7 → 24,7 |
opCOPYA* = 6; opCASET* = 7; opMULC* = 8; opMUL* = 9; opDIV* = 10; opMOD* = 11; |
opDIVL* = 12; opMODL* = 13; opDIVR* = 14; opMODR* = 15; opUMINUS* = 16; |
opADD* = 17; opSUB* = 18; opONERR* = 19; opSUBL* = 20; opADDC* = 21; opSUBR* = 22; |
opSAVE* = 23; opSAVEC* = 24; opSAVE8* = 25; opSAVE8C* = 26; opCHKBYTE* = 27; opDROP* = 28; |
opSAVE* = 23; opSAVEC* = 24; opSAVE8* = 25; opSAVE8C* = 26; (*opCHKBYTE* = 27;*) opDROP* = 28; |
opNOT* = 29; |
opEQ* = 30; opNE* = opEQ + 1; opLT* = opEQ + 2; opLE* = opEQ + 3; opGT* = opEQ + 4; opGE* = opEQ + 5 (* 35 *); |
72,7 → 72,7 |
opPUSHT* = 169; opTYPEGR* = 170; opISREC* = 171; opCHKIDX* = 172; opPARAM* = 173; |
opCHKIDX2* = 174; opLEN* = 175; opROT* = 176; opSAVES* = 177; opSADR* = 178; opLENGTHW* = 179; |
opCHR* = 180; opENDSW* = 181; opLEAVEF* = 182; opCLEANUP* = 183; opMOVE* = 184; |
(*opCHR* = 180;*) opENDSW* = 181; opLEAVEF* = 182; opCLEANUP* = 183; opMOVE* = 184; |
opLSR* = 185; opLSR1* = 186; opLSR2* = 187; |
opMIN* = 188; opMINC* = 189; opMAX* = 190; opMAXC* = 191; opSYSVALIGN16* = 192; |
opEQB* = 193; opNEB* = 194; opINF* = 195; opWIN64ALIGN16* = 196; opVLOAD8* = 197; opGLOAD8* = 198; |
80,7 → 80,7 |
opLOAD64* = 202; opLLOAD64* = 203; opVLOAD64* = 204; opGLOAD64* = 205; opSAVE64* = 206; |
opTYPEGD* = 207; opCALLI* = 208; opPUSHIP* = 209; opSAVEIP* = 210; opEQIP* = 211; opNEIP* = 212; |
opSAVE16C* = 213; opWCHR* = 214; opHANDLER* = 215; |
opSAVE16C* = 213; (*opWCHR* = 214;*) opHANDLER* = 215; |
opSYSVCALL* = 216; opSYSVCALLI* = 217; opSYSVCALLP* = 218; opFNAME* = 219; opFASTCALL* = 220; |
265,12 → 265,22 |
END PutByte; |
PROCEDURE AlignData (n: INTEGER); |
BEGIN |
WHILE CHL.Length(codes.data) MOD n # 0 DO |
PutByte(0) |
END |
END AlignData; |
PROCEDURE putstr* (s: ARRAY OF CHAR): INTEGER; |
VAR |
i, n, res: INTEGER; |
BEGIN |
IF TARGETS.WinLin THEN |
AlignData(16) |
END; |
res := CHL.Length(codes.data); |
i := 0; |
n := LENGTH(s); |
WHILE i < n DO |
290,6 → 300,9 |
BEGIN |
IF codes.charoffs[c] = -1 THEN |
IF TARGETS.WinLin THEN |
AlignData(16) |
END; |
res := CHL.Length(codes.data); |
PutByte(c); |
PutByte(0); |
307,13 → 320,13 |
i, n, res: INTEGER; |
BEGIN |
IF TARGETS.WinLin THEN |
AlignData(16) |
ELSE |
AlignData(2) |
END; |
res := CHL.Length(codes.data); |
IF ODD(res) THEN |
PutByte(0); |
INC(res) |
END; |
n := STRINGS.Utf8To16(s, codes.wstr); |
i := 0; |
341,13 → 354,13 |
BEGIN |
IF codes.wcharoffs[c] = -1 THEN |
IF TARGETS.WinLin THEN |
AlignData(16) |
ELSE |
AlignData(2) |
END; |
res := CHL.Length(codes.data); |
IF ODD(res) THEN |
PutByte(0); |
INC(res) |
END; |
IF TARGETS.LittleEndian THEN |
PutByte(c MOD 256); |
PutByte(c DIV 256) |
/programs/develop/oberon07/source/MSP430.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2019-2021, Anton Krotov |
Copyright (c) 2019-2022, Anton Krotov |
All rights reserved. |
*) |
984,11 → 984,6 |
drop; |
Op2(opMOV + bw(param2 = 1), src_x(param1, SR), dst_x(0, reg2)) |
|IL.opCHKBYTE: |
BinOp(reg1, reg2); |
Op2(opCMP, imm(256), reg1); |
jcc(jb, param1) |
|IL.opCHKIDX: |
UnOp(reg1); |
Op2(opCMP, imm(param2), reg1); |
1412,10 → 1407,6 |
Test(ACC); |
jcc(jne, param1) |
|IL.opCHR: |
UnOp(reg1); |
Op2(opAND, imm(255), reg1) |
|IL.opABS: |
UnOp(reg1); |
Test(reg1); |
/programs/develop/oberon07/source/PROG.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
*) |
41,6 → 41,7 |
sysPUT8* = 35; sysPUT16* = 36; stCOPY* = 37; stWCHR* = 38; |
sysWSADR* = 39; sysPUT32* = 40; (*sysNOP* = 41; sysEINT* = 42; |
sysDINT* = 43;*)sysGET8* = 44; sysGET16* = 45; sysGET32* = 46; |
sysVAL* = 47; |
default32* = 2; _default32* = default32 + 1; |
stdcall* = 4; _stdcall* = stdcall + 1; |
239,13 → 240,18 |
PROCEDURE getOffset* (varIdent: IDENT): INTEGER; |
VAR |
size: INTEGER; |
size, glob_align: INTEGER; |
BEGIN |
IF varIdent.offset = -1 THEN |
size := varIdent._type.size; |
IF varIdent.global THEN |
IF UTILS.Align(program.bss, varIdent._type.align) THEN |
IF TARGETS.WinLin THEN |
glob_align := 16 |
ELSE |
glob_align := varIdent._type.align |
END; |
IF UTILS.Align(program.bss, glob_align) THEN |
IF UTILS.maxint - program.bss >= size THEN |
varIdent.offset := program.bss; |
INC(program.bss, size) |
1109,6 → 1115,7 |
EnterProc(unit, "put8", idSYSPROC, sysPUT8); |
EnterProc(unit, "code", idSYSPROC, sysCODE); |
EnterProc(unit, "move", idSYSPROC, sysMOVE); |
EnterProc(unit, "val", idSYSPROC, sysVAL); |
(* |
IF program.target.sys = mConst.Target_iMSP430 THEN |
EnterProc(unit, "nop", idSYSPROC, sysNOP); |
1256,7 → 1263,11 |
IF TARGETS.RealSize # 0 THEN |
program.stTypes.tREAL := enterType(tREAL, TARGETS.RealSize, 0, NIL); |
IF TARGETS.OS = TARGETS.osLINUX32 THEN |
program.stTypes.tREAL.align := 4 |
ELSE |
program.stTypes.tREAL.align := TARGETS.RealSize |
END |
END; |
program.stTypes.tSTRING := enterType(tSTRING, TARGETS.WordSize, 0, NIL); |
/programs/develop/oberon07/source/RVMxI.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2020-2021, Anton Krotov |
Copyright (c) 2020-2022, Anton Krotov |
All rights reserved. |
*) |
790,14 → 790,6 |
UnOp(r1); |
Emit(opLSRC, r1, param2 MOD (szWord * 8)) |
|IL.opCHR: |
UnOp(r1); |
Emit(opANDC, r1, 255) |
|IL.opWCHR: |
UnOp(r1); |
Emit(opANDC, r1, 65535) |
|IL.opABS: |
UnOp(r1); |
Emit(opCMPC, r1, 0); |
958,11 → 950,6 |
END; |
drop |
|IL.opCHKBYTE: |
BinOp(r1, r2); |
Emit(opCMPC, r1, 256); |
Emit(opJBT, param1, 0) |
|IL.opCHKIDX: |
UnOp(r1); |
Emit(opCMPC, r1, param2); |
/programs/develop/oberon07/source/STATEMENTS.ob07 |
---|
402,12 → 402,6 |
IL.AddCmd(IL.opSAVE8C, ARITH.Int(e.value)) |
END |
ELSE |
IF chkBYTE IN Options.checking THEN |
label := IL.NewLabel(); |
IL.AddCmd2(IL.opCHKBYTE, label, 0); |
IL.OnError(line, errBYTE); |
IL.SetLabel(label) |
END; |
IL.AddCmd0(IL.opSAVE8) |
END |
END |
1062,7 → 1056,7 |
IF chkCHR IN Options.checking THEN |
CheckRange(256, pos.line, errCHR) |
ELSE |
IL.AddCmd0(IL.opCHR) |
IL.AddCmd(IL.opMODR, 256) |
END |
END |
1077,7 → 1071,7 |
IF chkWCHR IN Options.checking THEN |
CheckRange(65536, pos.line, errWCHR) |
ELSE |
IL.AddCmd0(IL.opWCHR) |
IL.AddCmd(IL.opMODR, 65536) |
END |
END |
1392,6 → 1386,8 |
field: PROG.FIELD; |
pos: PARS.POSITION; |
t, idx: PARS.EXPR; |
sysVal: BOOLEAN; |
n: INTEGER; |
PROCEDURE LoadAdr (e: PARS.EXPR); |
1444,7 → 1440,6 |
_type: PROG._TYPE; |
BEGIN |
IF chkIDX IN Options.checking THEN |
label := IL.NewLabel(); |
IL.AddCmd2(IL.opCHKIDX2, label, 0); |
1477,12 → 1472,35 |
BEGIN |
qualident(parser, e); |
sysVal := (e.obj = eSYSPROC) & (e.stproc = PROG.sysVAL); |
IF sysVal THEN |
PARS.checklex(parser, SCAN.lxLROUND); |
PARS.Next(parser); |
getpos(parser, pos); |
designator(parser, e); |
PARS.check(isVar(e), pos, 93); |
IF PROG.isOpenArray(e._type) THEN |
n := PROG.Dim(e._type); |
WHILE n > 0 DO |
IL.drop; |
DEC(n) |
END |
END; |
PARS.checklex(parser, SCAN.lxCOMMA); |
PARS.Next(parser); |
getpos(parser, pos); |
qualident(parser, t); |
PARS.check(t.obj = eTYPE, pos, 79); |
e._type := t._type; |
PARS.checklex(parser, SCAN.lxRROUND); |
PARS.Next(parser) |
END; |
IF e.obj IN {ePROC, eIMP} THEN |
PROG.UseProc(parser.unit, e.ident.proc) |
END; |
IF isVar(e) THEN |
IF isVar(e) & ~sysVal THEN |
LoadAdr(e) |
END; |
2599,6 → 2617,9 |
NextPos(parser, pos); |
expression(parser, e1); |
IF (e._type.typ = PROG.tBYTE) & (e1.obj # eCONST) & (e1._type.typ = PROG.tINTEGER) & (chkBYTE IN Options.checking) THEN |
CheckRange(256, pos.line, errBYTE) |
END; |
IL.setlast(endcall.prev(IL.COMMAND)); |
/programs/develop/oberon07/source/TARGETS.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2019-2021, Anton Krotov |
Copyright (c) 2019-2021, 2023, Anton Krotov |
All rights reserved. |
*) |
67,7 → 67,7 |
target*, CPU*, BitDepth*, OS*, RealSize*, WordSize*, AdrSize*, InstrSize*: INTEGER; |
ComLinePar*, LibDir*, FileExt*: STRING; |
Import*, Dispose*, RTL*, Dll*, LittleEndian*: BOOLEAN; |
Import*, Dispose*, RTL*, Dll*, LittleEndian*, WinLin*: BOOLEAN; |
PROCEDURE Enter (idx, CPU, RealSize, OS: INTEGER; ComLinePar, LibDir, FileExt: STRING); |
110,6 → 110,7 |
Dispose := ~(target IN noDISPOSE); |
RTL := ~(target IN noRTL); |
Dll := target IN {Linux32SO, Linux64SO, Win32DLL, Win64DLL, KolibriOSDLL}; |
WinLin := OS IN {osWIN32, osLINUX32, osWIN64, osLINUX64}; |
WordSize := BitDepth DIV 8; |
AdrSize := WordSize |
END |
/programs/develop/oberon07/source/THUMB.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2019-2021, Anton Krotov |
Copyright (c) 2019-2022, Anton Krotov |
All rights reserved. |
*) |
91,7 → 91,11 |
RELOCCODE = ARRAY 7 OF INTEGER; |
MEM = RECORD |
start, size, startReserve, endReserve: INTEGER |
END; |
VAR |
R: REG.REGS; |
105,11 → 109,9 |
StkCount: INTEGER; |
Target: RECORD |
FlashAdr, |
SRAMAdr, |
flash, sram: MEM; |
IVTLen, |
MinStack, |
Reserved: INTEGER; |
MinStkSize: INTEGER; |
InstrSet: SET; |
isNXP: BOOLEAN |
END; |
1151,14 → 1153,13 |
PushAll(0) |
|IL.opPARAM: |
n := param2; |
IF n = 1 THEN |
IF param2 = 1 THEN |
UnOp(r1); |
push(r1); |
drop |
ELSE |
ASSERT(R.top + 1 <= n); |
PushAll(n) |
ASSERT(R.top + 1 <= param2); |
PushAll(param2) |
END |
|IL.opCLEANUP: |
1587,14 → 1588,6 |
Tst(r1); |
SetCC(jne, r1) |
|IL.opCHR: |
UnOp(r1); |
Code(0B2C0H + r1 * 9) (* uxtb r1, r1 *) |
|IL.opWCHR: |
UnOp(r1); |
Code(0B280H + r1 * 9) (* uxth r1, r1 *) |
|IL.opASR, IL.opROR, IL.opLSL, IL.opLSR: |
BinOp(r1, r2); |
Shift(opcode, r1, r2); |
1620,11 → 1613,6 |
END |
END |
|IL.opCHKBYTE: |
BinOp(r1, r2); |
CmpConst(r1, 256); |
jcc(jb, param1) |
|IL.opCHKIDX: |
UnOp(r1); |
CmpConst(r1, param2); |
2344,16 → 2332,23 |
END epilog; |
PROCEDURE SetTarget (FlashStart, SRAMStart: INTEGER; InstrSet: SET; isNXP: BOOLEAN); |
PROCEDURE SetTarget (FlashStart, FlashSize, FlashReserve, SRAMStart, SRAMSize, SRAMReserve: INTEGER; InstrSet: SET; isNXP: BOOLEAN); |
BEGIN |
Target.FlashAdr := FlashStart; |
Target.SRAMAdr := SRAMStart; |
Target.flash.start := FlashStart; |
Target.flash.size := FlashSize; |
(*Target.flash.startReserve := 0;*) |
Target.flash.endReserve := FlashReserve; |
Target.sram.start := SRAMStart; |
Target.sram.size := SRAMSize; |
Target.sram.startReserve := 0; |
Target.sram.endReserve := SRAMReserve; |
Target.InstrSet := InstrSet; |
Target.isNXP := isNXP; |
Target.IVTLen := 256; (* >= 192 *) |
Target.Reserved := 0; |
Target.MinStack := 512; |
Target.MinStkSize := 256; |
END SetTarget; |
2360,17 → 2355,13 |
PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS); |
VAR |
opt: PROG.OPTIONS; |
i, j, DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER; |
ram, rom, i, j: INTEGER; |
DataAdr, BssAdr, DataSize, BssSize, CodeSize: INTEGER; |
BEGIN |
ram := MIN(MAX(options.ram, minRAM), maxRAM) * 1024; |
rom := MIN(MAX(options.rom, minROM), maxROM) * 1024; |
IF target = TARGETS.STM32CM3 THEN |
SetTarget(08000000H, 20000000H, CortexM3, FALSE) |
SetTarget(08000000H, MIN(MAX(options.rom, minROM), maxROM) * 1024, 0, |
20000000H, MIN(MAX(options.ram, minRAM), maxRAM) * 1024, 0, |
CortexM3, FALSE) |
END; |
tcount := CHL.Length(IL.codes.types); |
2384,13 → 2375,13 |
StkCount := 0; |
DataAdr := Target.SRAMAdr + Target.Reserved; |
DataSize := CHL.Length(IL.codes.data) + tcount * 4 + Target.Reserved; |
DataAdr := Target.sram.start + Target.sram.startReserve; |
DataSize := CHL.Length(IL.codes.data) + tcount * 4 + Target.sram.startReserve; |
WHILE DataSize MOD 4 # 0 DO |
CHL.PushByte(IL.codes.data, 0); |
INC(DataSize) |
END; |
BssAdr := DataAdr + DataSize - Target.Reserved; |
BssAdr := DataAdr + DataSize - Target.sram.startReserve; |
IL.set_bss(MAX(IL.codes.bss, MAX(IL.codes.dmin - CHL.Length(IL.codes.data), 4))); |
2397,20 → 2388,20 |
BssSize := IL.codes.bss; |
ASSERT(UTILS.Align(BssSize, 4)); |
prolog(BssSize, tcount, ORD(opt.pic), Target.SRAMAdr + ram, Target.IVTLen); |
prolog(BssSize, tcount, ORD(opt.pic), Target.sram.start + Target.sram.size - Target.sram.endReserve, Target.IVTLen); |
translate(ORD(opt.pic), tcount * 4); |
epilog; |
fixup(Target.FlashAdr, DataAdr, BssAdr); |
fixup(Target.flash.start, DataAdr, BssAdr); |
INC(DataSize, BssSize); |
CodeSize := CHL.Length(program.code); |
IF CodeSize > rom THEN |
IF CodeSize > Target.flash.size - Target.flash.endReserve THEN |
ERRORS.Error(203) |
END; |
IF DataSize > ram - Target.MinStack THEN |
IF DataSize > Target.sram.size - Target.MinStkSize - Target.sram.endReserve THEN |
ERRORS.Error(204) |
END; |
2426,15 → 2417,17 |
WR.Create(outname); |
HEX.Data2(program.code, 0, CodeSize, high(Target.FlashAdr)); |
HEX.Data2(program.code, 0, CodeSize, high(Target.flash.start)); |
HEX.End; |
WR.Close; |
C.Dashes; |
C.String( " rom: "); C.Int(CodeSize); C.String(" of "); C.Int(rom); C.String(" ("); C.Int(CodeSize * 100 DIV rom); C.StringLn("%)"); |
C.String( " rom: "); C.Int(CodeSize); C.String(" of "); C.Int(Target.flash.size - Target.flash.endReserve); |
C.String(" ("); C.Int(CodeSize * 100 DIV (Target.flash.size - Target.flash.endReserve)); C.StringLn("%)"); |
C.Ln; |
C.String( " ram: "); C.Int(DataSize); C.String(" of "); C.Int(ram); C.String(" ("); C.Int(DataSize * 100 DIV ram); C.StringLn("%)") |
C.String( " ram: "); C.Int(DataSize); C.String(" of "); C.Int(Target.sram.size - Target.sram.endReserve); |
C.String(" ("); C.Int(DataSize * 100 DIV (Target.sram.size - Target.sram.endReserve)); C.StringLn("%)") |
END CodeGen; |
/programs/develop/oberon07/source/UTILS.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
*) |
23,8 → 23,8 |
max32* = 2147483647; |
vMajor* = 1; |
vMinor* = 57; |
Date* = "31-aug-2022"; |
vMinor* = 63; |
Date* = "21-jan-2023"; |
FILE_EXT* = ".ob07"; |
RTL_NAME* = "RTL"; |
/programs/develop/oberon07/source/X86.ob07 |
---|
1,7 → 1,7 |
(* |
BSD 2-Clause License |
Copyright (c) 2018-2022, Anton Krotov |
Copyright (c) 2018-2023, Anton Krotov |
All rights reserved. |
*) |
954,14 → 954,13 |
jmp(param1) |
|IL.opPARAM: |
n := param2; |
IF n = 1 THEN |
IF param2 = 1 THEN |
UnOp(reg1); |
push(reg1); |
drop |
ELSE |
ASSERT(R.top + 1 <= n); |
PushAll(n) |
ASSERT(R.top + 1 <= param2); |
PushAll(param2) |
END |
|IL.opCLEANUP: |
1438,11 → 1437,6 |
pushc(param1); |
CallRTL(pic, IL._move) |
|IL.opCHKBYTE: |
BinOp(reg1, reg2); |
cmprc(reg1, 256); |
jcc(jb, param1) |
|IL.opCHKIDX: |
UnOp(reg1); |
cmprc(reg1, param2); |
1557,14 → 1551,6 |
CallRTL(pic, IL._lengthw); |
GetRegA |
|IL.opCHR: |
UnOp(reg1); |
andrc(reg1, 255) |
|IL.opWCHR: |
UnOp(reg1); |
andrc(reg1, 65535) |
|IL.opASR, IL.opROR, IL.opLSL, IL.opLSR: |
UnOp(reg1); |
IF reg1 # ecx THEN |
1828,8 → 1814,17 |
|IL.opNEW: |
PushAll(1); |
CASE TARGETS.OS OF |
|TARGETS.osWIN32: |
n := param2 + 4; |
ASSERT(UTILS.Align(n, 4)) |
|TARGETS.osLINUX32: |
n := param2 + 16; |
ASSERT(UTILS.Align(n, 16)) |
|TARGETS.osKOS: |
n := param2 + 8; |
ASSERT(UTILS.Align(n, 32)); |
ASSERT(UTILS.Align(n, 32)) |
END; |
pushc(n); |
pushc(param1); |
CallRTL(pic, IL._new) |
2444,6 → 2439,19 |
END epilog; |
PROCEDURE align16* (bit64: BOOLEAN); |
BEGIN |
IF TARGETS.WinLin THEN |
WHILE CHL.Length(IL.codes.data) MOD 16 # 0 DO |
CHL.PushByte(IL.codes.data, 0) |
END; |
WHILE CHL.Length(IL.codes.types) MOD (4 - 2*ORD(bit64)) # 0 DO |
CHL.PushInt(IL.codes.types, 0) |
END |
END |
END align16; |
PROCEDURE CodeGen* (outname: ARRAY OF CHAR; target: INTEGER; options: PROG.OPTIONS); |
VAR |
dllret, dllinit, sofinit: INTEGER; |
2451,6 → 2459,7 |
BEGIN |
FR[0] := 0; |
align16(FALSE); |
tcount := CHL.Length(IL.codes.types); |
opt := options; |
2476,7 → 2485,6 |
epilog(opt.pic, outname, target, opt.stack, opt.version, dllinit, dllret, sofinit); |
BIN.fixup(program); |
IF TARGETS.OS = TARGETS.osWIN32 THEN |
PE32.write(program, outname, target = TARGETS.Win32C, target = TARGETS.Win32DLL, FALSE) |
ELSIF target = TARGETS.KolibriOS THEN |
2486,7 → 2494,6 |
ELSIF TARGETS.OS = TARGETS.osLINUX32 THEN |
ELF.write(program, outname, sofinit, target = TARGETS.Linux32SO, FALSE) |
END |
END CodeGen; |