# Expected results for tests/fixtures/*.pas - one line per fixture: # # OK # ERR # # Both the verdict AND the numbers are asserted by run_compile_tests.sh, so a # regression in the *reported error position* fails the suite just like a # regression in the generated code. That matters: error positions were once # silently wrong (a multi-character string literal swallowed the rest of the # source, so every later error pointed at end-of-file), and nothing caught it # because the old harness only printed the position for a human to squint at. # # Re-baseline deliberately, never to make a red test go green: if a fixture's # expectation has to change because the compiler legitimately improved, change # it in the same commit as the fix and say why in the message. # # ERR 102 = ENoLib, the original's "not implemented" path. The remaining ERR # rows are unimplemented features, not parser bugs: # t14 'array [..] of ' at its point of use # t25 a string literal used where a 16-bit word is wanted # uierror deliberate syntax error, pinned by the editor UI test # # The nine control-flow fixtures (t08 t09 t10 t11 t12 t13 t15 t27 t28) were # re-baselined upward when they were rewritten to PRINT their result, so each # has a .out file and is executed under qemu (run_com_exec.py) as well as # compiled here. Before that they assigned to a variable and fell off the end: # they asserted that the compiler produced bytes, and nothing about behaviour. # t13 also gained a second procedure, which is why it is bigger than the sum of # its parts. t08's data went 6 -> 7 because a CHAR variable joined the INTEGER. # # t02 t03 t05 t17 used to be ERR 102 as well: a multi-character literal was # rejected because writeln had no string support. They compile now, via the # inline-string path (CALL wrtinl, then in the code stream - # TPSRC8 pwrinlin / TPSRC4 xwrtinl), so their rows changed from ERR to OK and # their code sizes went up by the literal's own bytes. # # RE-BASELINED for v-TP3-8086-LOWERING, when conditional branches and SETcc # stopped being 386-only. Nine rows moved, every one of them UPWARD, and every # one of them by exactly the number of conditional sites in that fixture: # # +1 per site. A branch was 4 bytes (0F 8x rel16) and is now 5 (7x 03, # then the 3-byte EJMP). A comparison VALUE was 5 bytes (0F 9x rel8, then # MOV AH,0) and is now 6 (B8 01 00, 7x 01, DEC AX). So the deltas are # t09 +6 = 3 values + 3 branches, t10 +4 = 2+2, t11 +2 = 0+2, # t12 +4 = 2+2, t15 +2 = 1+1, t22 +2 = 0+2, t30 +1 = 0+1, t32 +3 = 1+2, # t33 +13 = 13 values. # # That arithmetic was CHECKED, not assumed: the site counts were counted out of # the linked images (the same CMP AX,CX and CMP AX,0000 anchors and the same # 7x 03 E9 shape that check_8086.py uses) and each row was only written after # its delta matched its count. Data sizes did not move at all. The bytes # themselves are pinned by check_8086.py, and the BEHAVIOUR is pinned by # run_com_exec.py -- this row only says how big the code is. # # RE-BASELINED when the runtime was wired into the code buffer. Every OK row # changed by exactly +3 code and -256 data, and both numbers are correct: # # +3 code the prologue now emits MOV AX,
before # CALL TU_InitMem, because InitMem takes the header offset in a # register (B8 lo hi) rather than on the stack. Previously the # prologue called offset 8, which is the hdrMax word - it only # "worked" because the runtime was not in the image at all. # # -256 data DataBytes() used to return dc, the ABSOLUTE end of the data # area, not a size. dc started at 100H, so every program reported # 256 more than it allocated - 260 for a program whose only data is # the two @@T1/@@T2 scratch words. The field is documented as # "emitted data size in bytes", so 4 is the true size and 260 was # the bug. It is a real correction, not a fit-to-the-test change: # the 6-byte rows are the fixtures that declare one global. # # ADDED for the BP displacement fix. These two fixtures are the first with # any frame access at all -- every earlier fixture put its variables in the # DATA segment, addressed absolutely, so the whole [BP+off] path had zero # coverage and a truncation there was invisible. # # t27_localvar five LOCAL variables, assigned and read back. Locals are # allocated downward from 0FFFEh and each access now costs 4 # bytes (mod=10 + disp16) where it cost 3 (disp8), so its code # size reflects the fix rather than predating it. Both # encodings address the same place; only the rule for choosing # between them changed. # t28_farparam 70 declared parameters; the call passes 16, which is the # argument cap at the call site. Under TP3's frame rule the # LAST declared parameter is the one at BP+4, so p8 lands at # BP+128 and p1 at BP+142 - the first offsets a disp8 cannot # represent, since 80h is -128 and not +128. Under the old # code these two reads came from the wrong side of BP. This # fixture tests the ENCODING; it is executed too, but its .out # carries only the deterministic sum of the two slots the # sixteen pushed arguments land in (p55 + p70), never the # stack garbage that p1..p54 read. Do not read it as a claim # that a 70-argument call works. # # RE-BASELINED for the case-label fix, and this is the one re-baseline in this # file that is a CORRECTION rather than a new feature. EmMovAxSp used to emit # # 8B 44 24 00 MOV AX,[SP] <- 386 encoding, SIB byte # # which is 4 bytes. [SP] is not encodable on the 8086 at all: mod=00/rm=100 # is [SI], and the SIB byte that 8B 44 needs did not exist until the 386. The # bytes were well formed, so every byte-level check passed, and fcml and qemu # both DECODED it - as MOV AX,[SI+0x24h], because that is what it is. Every # CASE label test therefore loaded a garbage address, every comparison failed, # and a case statement fell straight past its body. It now emits # # 58 50 POP AX ; PUSH AX <- 2 bytes # # which is observationally a peek. t22 has two labels, so its code is exactly # 4 bytes smaller: 96 -> 92. The number moving is the point - the old size was # the size of a wrong encoding, and a case fixture that is not executed cannot # tell you that from its size alone. t22 is executed (tests/run_com_exec.py). # # ADDED t29_readln: the first fixture that reads. It needs the CHAR class to # exist at all - see the note on TChar in Compiler.mod - so 7 data bytes where # t19 has 4 (n is 2, c is 1, and the two are 2-byte aligned, so 4 + 2 + 1 # rounds up to 7) and 82 code bytes for the four runtime calls plus a literal # char argument. Its .out is compared byte for byte against qemu. # # RE-BASELINED for the procedure-skip jump. t13, t27 and t28 gained exactly # +3 code bytes: `E9 rel16`. These are the only three fixtures that declare a # PROCEDURE, and they are the only three rows that moved. # # The reason is a bug that only execution could find. The declaration part is # compiled BEFORE the main statement part, so a procedure's code lands between # the program prologue and the main body - and nothing jumped over it. A # program with a procedure ran off the end of the prologue straight into the # first procedure, which read its argument out of an uninitialised frame and # returned to address 0000h. t13_proc compiled, produced a plausible 53 bytes, # and was never run, so the suite was green over a program that could not # execute at all. # # The jump is emitted ONLY when a procedure or function is declared, which is # why the other 27 OK rows did not move. That condition is a lookahead over # the source buffer, because the jump must be emitted before the declaration # part but whether one is needed is only known after - see DeclaresProc in # Compiler.mod for why the alternative (always emit it) was rejected. # # t13_proc 53 -> 56 # t27_localvar 122 -> 125 # t28_farparam 123 -> 126 # t31_procparam 66 -> 69 # # t31_procparam is the fixture that proves the fix by running: it declares a # procedure, calls it, and prints what the procedure wrote. Before the fix it # never halted at all. # # ADDED t30/t31/t32, all three now EXECUTED (not just compiled): # # t30_forloop `for i := 1 to 5 do s := s + i` printed 21, not 15. The loop # test was emitted AFTER the body, making it a post-test loop: # the body ran a sixth time with i = 6. The code size and the # instruction bytes were both already correct - only the ORDER # was wrong, and no byte-level check can observe an order. The # test now precedes the body, so 96 bytes both before and after # this fix, which is the whole point: the number never moved and # the behaviour did. # t31_procparam procedure + one parameter. The non-termination above. # t32_forexit `for` with `exit` in the body. Two faults, both invisible to # a size check: the loop's exits were patched to the position # just past the body, which in a FOR is the STEP, so `exit` # incremented the control variable and jumped back into the test # - it did not exit; and the EXIT handler also emitted ADD SP,2 # while the loop's `done` label emitted it again, dropping four # bytes off a stack that had two to give. Exits are now patched # at `done`, and the handler no longer touches the stack. # t33_cmpops all six relational operators as VALUES, each with a true case, # a false case and the equality boundary, plus one signed pair. # Added while making the 8086 branch/compare lowering checkable: # measuring which conditions the suite actually emitted showed # that `=', `<>' and `<=' were never used in a comparison at all, # because `writeln (a = b)` had no fixture. Only `<', `>' and # `>=' had coverage - and `>' vs `>=' had ALREADY been swapped # once (bug 29), so a hole either side of the operators that # were covered is the last place to leave one. m := -1, n := -2 # makes the last line signed: unsigned, -1 > -2 is FALSE, so that # one line is what tells SETG from a byte compare. # # t36_argclobber eight lines of hand-derived output, added BEFORE the fix it # covers: this row was written while the compiler still lost a # computed argument, was proved red by running it, and its # numbers did not move when the fix landed - the fix reorders # bytes rather than adding them, so the same size came out of a # different order. A number that never moved and a behaviour # that did is the same shape as t30 above. t01_minimal OK 29 4 t02_writeln OK 38 4 t03_inline_comment OK 38 4 t04_var OK 48 6 t05_own_line_comment OK 38 4 t06_two_args OK 52 4 t07_big OK 102 6 t08_const OK 76 7 t09_if OK 195 6 t10_while OK 151 6 t11_for OK 144 6 t12_repeat OK 137 6 t13_proc OK 126 6 t14_types ERR 102 83 t15_label OK 90 6 t16_str1 OK 42 4 t17_two_str OK 45 4 t18_writeln_bare OK 32 4 t19_int1 OK 42 4 t20_str3 OK 62 4 t21_mixed OK 62 4 t22_case OK 94 6 t23_str_empty OK 36 4 t24_str_quote OK 41 4 t25_str_as_value ERR 102 48 t26_str_mixed_args OK 58 4 t27_localvar OK 256 6 t28_farparam OK 153 8 t29_readln OK 82 7 t30_forloop OK 97 8 t31_procparam OK 69 6 t32_forexit OK 138 8 t33_cmpops OK 404 12 t34_arith OK 448 8 t35_not OK 224 7 t36_argclobber OK 492 12 uierror ERR 41 331