Swordfish Wiki | SwordfishUser / SFIDF

The following represents the current state of the Swordfish Intermediate Debug File (IDF) which is currently being implemented. As such, it is work in progress. The IDF is a structured text based file which will enable the compiler to support simulation and debugging. In addition, information contained in the file would allow plugins to display both ROM and RAM usage for subroutines, functions, events and interrupt routines.

Sample Code

// simple xy structure...
Structure TXY
   x,y As Byte
End Structure 

// a type of TXY structure...
Type TMyType = TXY

// big structure...
Structure TStructure
   a,b,c As Byte
   xy As TMyType Union
   Alias As c
End Structure

// a function that return a structure...
Public Function MyFunc(pIndex As Byte) As TStructure
   Dim lValue As Byte
   lValue = pIndex
   result.a = lvalue
End Function

// module level variables...   
Dim MyStructure As TStructure
Dim OK,NotOK As Boolean
Dim Index As Byte
Dim Str As String
Dim AliasStr As Str
Dim ch As Str(10)

// main program...   
Index = 10
MyStructure = MyFunc(Index)
OK = true
NotOK = false
ch = "a"

Debug Output

The following shows the IDF output for the above program.

 .exe
   $000000 | $EF04 sys | 
   $000002 | $F000 sys | 
   $000008 | $8C18 sys | 
   $00000A | $D005 sys | 
   $00000C | $C019 000 | 000 00045 C00001 
   $00000E | $F01A 000 | 
   $000010 | $C01A 000 | 000 00046 C00001 
   $000012 | $F01B 000 | 
   $000014 | $0012 000 | 
   $000016 | $0E0A 000 | 000 00058 
   $000018 | $6E22 000 | 
   $00001A | $C022 000 | 000 00059 
   $00001C | $F019 000 | 
   $00001E | $DFF6 000 | 
   $000020 | $EE00 000 | 
   $000022 | $F01F 000 | 
   $000024 | $EE10 000 | 
   $000026 | $F01B 000 | 
   $000028 | $0E03 000 | 
   $00002A | $CFE6 000 | 
   $00002C | $FFEE 000 | 
   $00002E | $2EE8 000 | 
   $000030 | $D7FC 000 | 
   $000032 | $801E 000 | 000 00060 
   $000034 | $921E 000 | 000 00061 
   $000036 | $0E61 000 | 000 00062 
   $000038 | $6E2D 000 | 
   $00003C | $D7FE end | 
 .end

 .file
   001 SystemTypes "C:\Programming\Borland\Swordfish\Compiler\Swordfish\Includes\18F4680.BAS"
   000 MAIN "C:\Programming\Borland\Swordfish\Compiler\Swordfish\TestPrograms\debug\Debug.bas"
 .end

 .module 001 SystemTypes
   .var PUB $0D79 00 0000 0000 U08    RXF6SIDH
   .var PUB $0D7A 00 0000 0000 U08    RXF6SIDL
   ... and so on
   .var PUB $0F99 00 0000 0000 U08    PORTA
 .end

 .module 000 
   .import 001 SystemTypes
   .structure PRI 00001 0002 TXY
   .var 0000 0000 0000 U08    x
   .var 0008 0000 0000 U08    y
   .end
   .structure PRI 00002 0003 TStructure
   .var 0000 0000 0000 U08    a
   .var 0008 0000 0000 U08    b
   .var 0016 0000 0000 U08    c
   .var 0000 0000 0000 *00001 xy
   .var 0016 0000 0000 U08    Alias
   .end
   .func PUB 00001 $0000C 00010 $0019 0005 C000 00045 00046 MyFunc
   .var VAL $0019 00 0000 0000 U08    pIndex
   .var PRI $001A 00 0000 0000 U08    lValue
   .ret PUB $001B 00 0000 0000 *00002 MyFunc
   .end
   .var PRI $001E 00 0000 0000 U01    OK
   .var PRI $001E 01 0000 0000 U01    NotOK
   .var PRI $001F 00 0000 0000 *00002 MyStructure
   .var PRI $0022 00 0000 0000 U08    Index
   .var PRI $0023 00 0024 0000 U08    Str
   .var PRI $002D 00 0000 0000 U08    ch
 .end

Overview

Please note the following is preliminary and is likely to change.

.exe Section

The first section is the .exe block. For example,

F0	F1	F2	F3	F4	F5
$00000A	$0E0A	000	000	0058
$000012	$C019	000	000	0045	I00001

F0 - ROM address
F1 - Executable ROM code
F2 - The physical module that the executable ROM code is located. For example, a subroutine may be located in module 002 (see F3 below), but the code may be generated inline. For example, a physical module ID of 000 indicates that the code was generated inline in the main program. A "sys" descriptor denotes system or non-module code. For example, DelayMS()

The next three fields are optional. If present, they give information relating to a high level instruction. For example, "a = 10" or "if index < 10 then..."

F3 - The module ID that contains the high level instruction. See the files block for more information.
F4 - The instruction line number
F5 - A unique procedure, function, event or interrupt ID. The routine is inline if the ID is preceded with an "I", called if preceded with "C".

.file Section

The file section gives a unique module ID, module name and a fully qualifies path to the source file. For example,

   001 SystemTypes "C:\Programming\Borland\Swordfish\Compiler\Swordfish\Includes\18F4680.BAS"

.module Section

The modules section begins with a unique module ID followed by the module name. Every module section terminates with .end. For example,

 .module 002 MyModule
 .end

A module section can hold multiple debug types. For example, structures, variables and procedures.

.import

The .import keyword denotes modules that have been included. The .import keyword is followed by a unique module ID and module name.

.proc, .func, .event and .isr Section

The procedure section is always terminated with .end. For example,

 .func PUB 00001 $0000C 00010 $0019 0005 00045 00046 MyFunc
 .end

A procedure section can hold multiple debug types. For example, structures and variables. A procedure section consists of the following fields

F0	F1	F2	F3	F4	F5	F6	F7	F8
Scope	00001	$0000C	00010	$0019	0005	00045	00046	MyFunc

F0 - Scope identifier. Can be PRI or PUB.
F1 - Unique procedure ID
F2 - ROM start address in bytes
F3 - Total number of ROM bytes used
F4 - RAM start address in bytes
F5 - RAM used in bytes
F6 - Line start
F7 - Line end
F8 - Procedure name

.con

All information pertaining to a .con debug item is held on a single line and consists of the following fields

F0	F1	F2	F3	F4	F5
Scope	$000001A	0011	0000	U08	CString

F0 - Scope identifier. Can be PRI or PUB.
F1 - The starting ROM address of the variable.
F2 - The number of elements for first dimension. For example, an array or a string.
F3 - The number of elements for the second dimension. For example, an array of strings.
F4 - The element size in bits which is preceded by "U", "S" and "F" denoting unsigned, signed and floating point respectively.
F5 - The constant name.

Please note that .con debug items will only be generated for constants that are held in the compilers constant ROM table. These are typically strings and arrays. Constant debug entries are not made for single constant values that are generated within the main executable block.

.var

All information pertaining to a .var debug item is held on a single line and consists of the following fields

F0	F1	F2	F3	F4	F5	F6
Scope	$0019	00	0000	0000	U08	pIndex

F0 - Scope identifier. Can be PRI or PUB. For procedure arguments, a scope identifier can be VAL, REF or CON.
F1 - The starting RAM address of the variable.
F2 - Bit offset for the variable. Bits and booleans are typically packed into bytes. This field gives the bit offset.
F3 - The number of elements for first dimension. For example, an array or a string.
F4 - The number of elements for the second dimension. For example, an array of strings.
F5 - The element size in bits which is preceded by "U", "S" and "F" denoting unsigned, signed and floating point respectively. If preceded with a "*", the number is a pointer to a unique structure ID.
F6 - The variable name

.structure Section

A structure section is always terminated with .end. For example,

   .structure PRI 0001 002 TXY
   .end

A structure section can hold multiple .var types. A structure section consists of the following fields

F0	F1	F2	F3
Scope	00001	002	TXY

F0 - The structure scope. Can be PRI or PUB.
F1 - A unique structure ID
F2 - The total size of the structure in bytes
F3 - The structure name

A structure .var item has a slightly different format from other .var items, as no address information is present. For structure .var items, the fields are

F1	F2	F3	F4	F5
0000	0000	0000	U08	MyVar

F0 - The offset of the variable contained in the structure, in bits.
F1 - The number of elements for first dimension. For example, an array or a string.
F2 - The number of elements for the second dimension. For example, an array of strings.
F3 - The element size in bits which is preceded by "U", "S" and "F" denoting unsigned, signed and floating point respectively. If preceded with a "*", the number is a pointer to a unique structure ID.
F4 - The variable name

From Swordfish Wiki

SwordfishUser: SFIDF