I am working on the parser / assembler for a new flat assembler version supporting a new target.

My question is, I want to check the generated code in assembler section and tried to evaluate some data created with assembler directives. The problem: This works only with backward reference to already assembled code, not with forward reference.

So I tried to do same with load and store but they also work only with backward reference.

Example:



This works. When I try to do this with code generated "after" (second data block) this does not work (try to access $$+10h with load).
Value out of range appear.

This is really a pity. I don't understand why it is not possible because the parser could resolve this when just adding an additional pass.

In my program I only have to read code and adjust some (other) data when a special sequence occur. This does only work backward not forward.

I could write an "after parser" or "after assembler" process but this is very unconvenient to add. So the question is, is there a simple way to get this request running with FASM easily and are there special reasons why forward references are not allowed in this case ?

The data which should be read will not be changed anyway, just other data is adjusted. There will be no situation that the code could not be resolved in my case.

The reason you can't forward reference to future output is because the output does not yet exist when the load/store is encountered.

How would this work?

[ Post removed by author. ]

It would work the same way like forward reference of labels is resolved.

In the first pass byte at position 1 does not exist and can not be written.
This is the same condition when we reference a label which is not yet defined.

So the usual way to resolve is to do an additional pass and in the second pass the byte at position 1 is defined through the first pass and could be overwritten.
And of course a store reference has a higher priority than a simple data definition.

I think I did describe exactly what I want in my first post.

Such a scheme would entail delaying the processing of all load/store commands until assembly has finished. I guess it might be possible but it seems like too much effort to solve a problem that would be better solved by another means.

Yes you maybe right, but it would be a nice feature, wouldn't it ?

[ Post removed by author. ]

shutdownall

Bad analogy. Labels cannot be redefined. Load/store forward referencing is not possible for the same reason, that does not allow redefined numeric constants to be forward referenced. If you do a store, it's already a redefinition of what was stored before.
The revolution's example may be not that clearly emphasizes the problem. Look at this example:

What value should have x? Is that what we stored with the first store? Is that what should be resolved after the final pass? What number of passes do we need to resolve the following?

Bad example.
It depends on what you do and what you want.
As I pointed out I want to read only data and modify other data depending on it's content.

There can be always situations that can't be resolved regardless of using load / store or not.

What do you say to following code in an assembly section:
Is the redefinition of assembler time variables not allowed because it could be used in a bad way ?



Or next example with labels:



How many passes does it need ?

So I can accept that some functions not realized because they are not needed or planned that way but the reason of disabling features only because they could be missused or missinterpreted are not acceptable for me.

shutdownall

Obviously you didn't understand the examples. If the second example would backward reference the data, it would be a valid and quite common construction. By allowing load/store forward referencing you change the semantics of the load/store, which would also affect backward referencing. Thus your idea would break much more useful things, than it would allow to do.


None of these examples shows redefinition. In fact, if you tried to use redefinition, you wouldn't be able to forward-reference. As I already said the same situation occurs with forward-storing, cause storing is by definition a redefinition.


The reasoning behind not enabling load/store forward referencing is not just because it can be misused. Actually only rare cases exist, when it's possible to not misuse it.