Ytukyg

I am currently working with Microchip system and I have encountered program length problem. I can see two different length while compiling:

• length (PC unit)


• length (bytes)

And those two can really differ (0x1EC8 and 0x2700 for instance).

Do any of you know the difference between the two? Method to calculate them?

[EDIT] :
See .text section

I just gone through some books and got these explanations, it might be useful for you.

Bytes:

There is a minimum block of code that is always generated by the MPLAB
C compiler

Taken from the book: here

and

PC Units:

It may be Program Counter units. It is indicated that, The 16-bit
device PC increments by 2 for each instruction word (Not in all cases, please refer some books for PC increment in PICs)

Taken from the book: here

Page No: 52

So, they may not be the same size. Mostly Bytes size will be larger than PC Units.

Hope it is helpful :)

Maybe have a look at the PIC24FJ128GA:

Each instruction is 24 Bit or three Byte. The user Flash Program Memory starts at 0x200 and has a length of 0x155FC in Program Counter Units. Each even PC has two bytes and each odd PC has just one byte. So the total user program memory is 0x155FC * 1.5 = 131322 = 128.2K-byte.

This answer is focused on just the Microchip PIC devices in the PIC24, dsPIC30, and dsPIC33 families.

Controllers of this type have separated address buses for instruction and data memory.

The data memory is organized as 16-bit words and addressable as bytes.

The instruction memory is organized as 24-bit words.

When an op-code is fetched from the instruction memory all 24-bits are read at once.
But there are additional addressing modes that allow a portion of the instruction memory to be read using addressing modes available with data memory.

There are some other ways to access instruction memory but they are about erasing and writing the instruction memory so are not relevant to this answer.

When the controller is fetching instructions using only the program counter only even address are possible however it is possible to fetch instruction using indirect addressing. Developers should be careful using this method for control transfer like CALL and GOTO as address error traps can occur when the target address is odd.

For reasons I do not fully comprehend the portions of instruction memory visible using the modes available with data memory can only access the low 16-bits of an instruction word, the upper 8-bit cannot be accessed this way.

So I have described the shape of the memory buses in the 24-bit PICs but I've not answered your question.

Microchip documentation does not do a good job of describing this. It does a lot of hand waving and obscures useful details.

In essence there are 2 address units for every word of addressable memory. In the data memory this represents 2 bytes of RAM, for instruction memory the represents 3 bytes of FLASH, but one 2 of those 3 bytes are visible.

This treatment of instruction memory is "supposed" to make accessing this memory space for to read constant data faster and easier to create a C compiler code generator for. Hard to say it that is true.

So to sum up there are 3 bytes of FLASH for each instruction word. Each instruction word is represented by 2 address units.

To convert from address units to bytes of FLASH:

1. Count the range of FLASH address units (must be even).


2. Divide range by 2 to get the number of instruction words.


3. Multiply the number of instruction words by 3 for the number of bytes of FLASH memory.

For most practical purposes the number of bytes used of FLASH memory is of little use, though the number of instruction word assigned or free is more useful.

PC means program counter, so in that case the size is being given in program counter units (which depends on the length of the instructions and it determines the number of possible address that the PC can point to). In the other case, it just means the size in bytes.

In a constant-width instruction as a Microchip PIC24 is (which could match with your example), the instruction width is 3bytes, being the PC (never odd) incremented by 2 each instruction (16-bit data). So the relation between the length in bytes and the length in PC units is 3/2, in your example, a .text section of 0x1b0 bytes will be equivalent to 0x1b0 * (2 / 3) = 288 PC-Units

The term PC unit is an useful way to speak about addresses in devices whose instruction's width is bigger than 8-bites, especially for debugging (map files, addresses, offsets, sizes, etc), but I highly recommend you to work always in PC-units or always in bytes, in order to avoid stupid errors.

Bear in mind that several Microchip operators work with PC units, instead of bytes, such as .sizeof.., so these kind of operators won't report you the size in bytes, so you will have to know the architecture of your uC in case you want to convert to bytes.