format PE GUI 4.0

start:
ret

if start = 0
    display 'equals',13,10
else
    display 'differs',13,10
end if

section '.reloc' fixups readable discardable    

format PE GUI 4.0

start:
ret

virtual
      dq start
    load start.noreloc qword from $$
end virtual

if start.noreloc = start
     display 'non-relocatable',13,10
else
   display 'relocatable',13,10
end if

section '.reloc' fixups readable discardable    

format PE GUI 4.0

start:
ret

if fixate start = start
       display 'non-relocatable',13,10
else
   display 'relocatable',13,10
end if

section '.reloc' fixups readable discardable    

However if you make such comparison valid and returning always false for "=" and true for "<>" (I think, it's a reasonable modification)

And if you still want to add an additional operator, than a better idea would be to transform a relocatable value into a non-relocatable with an operator named "fixate" or "anchor" or "settle" (i.e. just remove the relocatability flag).

if mylabel relativeto 0    

If you compare non-relocatable value with a simple number, it can become "true" of "false" at the runtime depending on how your code was relocated, so it is something like writing "if eax=0" and expecting assembler to give definite answer.

such operator would not be very useful, because it would be equivalent to saying "subtract some value I don't know from this one".

;Displays a hexadecimal representation of a number
macro dispHex num*, padding, leader, trailer
{
 local digCount,dig,number
   
    number = num
        virtual
             dq number
           load number qword from $$
   end virtual
 if number < 0
            number = number + 100000000h
        end if
      digCount = 0
        while 1 shl (digCount*4) <= number
               digCount = digCount + 1
     end while
   if digCount = 0
             digCount = 1
        end if
      if ~ leader eq
              display leader
      end if
      if ~ padding eq
             if digCount < padding
                    times (padding-digCount) display '0'
              end if
      end if
      repeat digCount
             dig = number shr ((digCount-%)*4) and 0Fh+'0'
             if dig > '9'
                   dig = dig-'0'+('A'-10)
          end if
              display dig
 end repeat
  if ~ trailer eq
             display trailer
     end if
}    

it would be enough to do:

Code:

if mylabel relativeto 0    

$ relativeto 0    

;Allows to reduce code size by replacing <push const> with <push reg>
;usage:
;BeginRegIsConst ebx,0
;        mov eax,0
;EndRegIsConst
macro BeginRegIsConst reg*,const*
{
  local block_closed
  if ~ defined block_closed
           display 'Error: current block is not closed',13,10
            rb -1
       end if
      purge EndRegIsConst
 macro push [args]
   \{
            \common \local \isconst,\buf
                    \isconst = 0
                       if 0 eqtype args
                            virtual
                                     dq args
                                     load \buf qword from $$
                            end virtual
                         if \buf = const
                                    push reg
                                    \isconst = 1
                               end if
                      end if
                      if ~ \isconst
                              push args
                   end if
      \}
    macro mov [args]
    \{
            \common \local \isconst,\buf
                    \isconst = 0
                       match first=,second,args
                    \\{
                          if 0 eqtype second
                                  virtual
                                             dq second
                                           load \buf qword from $$
                                    end virtual
                                 if \buf = const
                                            mov first,reg
                                               \isconst = 1
                                       end if
                              end if
                      \\}
                  if ~ \isconst
                              mov args
                    end if
      \}
    macro pushd [args] \{ \common push args \}
     macro BeginRegIsConst dummy1*,dummy2*
       \{
            display 'Error: ',`reg,' still equals ',`const,13,10
                err
 \}
    macro EndRegIsConst \{ purge push,pushd,mov,BeginRegIsConst \}
  macro EndRegIsConst
 \{
            EndRegIsConst
               purge EndRegIsConst
         block_closed = 1
    \}
}    

First of all, I assume, you mean "compare a relocatable value". Because under "relocatable" I understand, that the value can be relocated (changed) at the load time.

Secondly, let me explain my point about returning false. Currently in your implementation every numeric value is a tuple, which consists of the actual value and the flag "relocatable"

(I'm not aware of ELF's abilities, probably it should be a tuple with the actual value and the currently computed base, if ELF's allow different code parts to be relocated asynchronously, i.e. with different deltas)

A tuple is equal to another tuple if and only if all of their corresponding components are equal.

Therefore it's absolutely logical to return inequality if the flag "relocatable" is not equal to the flag of the compared value.

Quote:

such operator would not be very useful, because it would be equivalent to saying "subtract some value I don't know from this one".

That's not true. I have my overloaded implementation of display, which allows to easily display numeric values. (...)

Quote:

it would be enough to do:

Code:

if mylabel relativeto 0    

Could you explain the functionality? Because I don't understand, why the same expression

Code:

$ relativeto 0    

with relocations enabled and without them would be evaluated differently.

if mylabel relativeto 0

  dd mylabel xor 0xABCD ; this is just a number, I can do any computations on it

else if mylabel relativeto ebp

  offset_in_stack = mylabel - ebp

else if mylabel relativeto $

  jmp mylabel ; I know this jump will never generate relocation

else if mylabel relativeto some_external_array

  offset_in_array = mylabel - some_external_array

end if    

Code:

else if mylabel relativeto ebp

  offset_in_stack = mylabel - ebp     

But even when they are not equal, the result values could become the same.

it is like returning false when you try to compare "eax" with "0"

on reading this output you may not be able to tell whether this is just some computed number (which will always be the same at run-time), or an address which can become something different at run-time

The "$ relativeto 0" would be false in relocatable format, and it is related to the fact that you cannot do computations like "($-0) shr 3" in such case

Code:

else if mylabel relativeto $ 
  jmp mylabel ; I know this jump will never generate relocation    

Well, yes. So what? The returned false is in this case the compile time comparison which does not have to reflect the run time. It has never been a problem for you to compare "eax" with "0" and return false when compared with eqtype. Why? Because it's just a different type of comparison. If you want a run time comparison, you always have cmp.

Wouldn't you know the jump will never generate relocation without checking this? Direct near/short jumps never generate relocations. To generate a relocation it should be indirect or far.

fasm makes sure that values you assume to be equal are equal and there was much effort put into ensuring that in whole fasm's architectural design.

In object format jump may generate relocation - when you jump to other section, or call the external procedure.

it would be enough to do:

Code:

if mylabel relativeto 0    

Also, would this be the first time fasm introduces a keyword composed of more than one word?

it is like saying two values are related to each other