use32

flood_BP_BTB:
    push    eax edx
;this should be the size of the instructions of 1 round of the repeat loop
;which also must be equal for the initialization, main and finitialization part
  .code_cell_size= 12

;initialization part
  repeat       31
  rdtsc
       bt      eax,%-1
     db      0Fh,82h ;jc     dword
       dd      (%-2) * .code_cell_size
  end repeat

;random seed.
;Uncomment the %t if you're feeling lucky and this will give you
;a different code each time you compile the code
  d= 03191BCF4h        ;03197BCF1h     ;%t
  h= d
;main part
  repeat 0DAh    ;0FBh
    h= h + 9E3779B97F4A7C15h           ;~ MAX_INT * (sqrt(5)/2 - 1/2)
    d= ((d shl 43 + d shr 21) xor h) + d;some random random-number function
       rdtsc
       bt      eax,(d and 1F00h) shr 8
     db      0Fh,82h ;jc     dword
       dd      ((d and 03Fh) - 20h) * .code_cell_size
  end repeat

;finitialization part
  repeat 32
  rdtsc
       bt      eax,32-%
    db      0Fh,82h ;jc     dword
       dd      (%-33) * .code_cell_size
  end repeat
    pop     edx eax
     ret
    

;initialization part
  repeat 31
   .current_cell = $
        rdtsc
        bt      eax,%-1
        jc      near  .current_cell + (%-1) * .code_cell_size
  end repeat
  .code_cell_size = $-.current_cell    

Writing those things like this would be perhaps more flexible (and easier to modify):

Code:

;initialization part
  repeat 31
   .current_cell = $
        rdtsc
        bt      eax,%-1
        jc      near  .current_cell + (%-1) * .code_cell_size
  end repeat
  .code_cell_size = $-.current_cell    

No DD instruction making, no hand-calculated sizes, etc.

The relative jump offsets are different and difficult to predict even at assembly time. Unfortunately, some of them fit into the short range and others don't (near range). Thus each JC instruction as you supposed it would have a different size and so the entire offset calculation as we both suggested it wouldn't work at all.

That's why I put the "near" keyword there, to ensure the instruction always has the same length (I checked the code before posting, so that it generates exactly the same bytes).

See this thread: http://board.flatassembler.net/topic.php?t=5162
In short, you can have "jc near dword" or "jc near word" to generate full-size jumps using either the EIP or IP, and "jc short dword" or "jc short word" to generate short jumps, also either EIP or IP.

  .code_cell_size = $-.current_cell    

use32 
 
flood_BP_BTB:
;this should be the size of all instructions of 1 round of the repeat loop
;which must also be equal for the initialization, main and finitialization part
;we can't know their exact values at this point, so we preset them to 0
init_code_cell_size = 0
code_cell_size           = 0
finit_code_cell_size     = 0

;the actual cell code
macro       init_code_cell  i {
    rdtsc
       bt      eax,i
       jc      near $+6 + (i -1) * init_code_cell_size
     jnc     near $+6 + (61-i) * init_code_cell_size
}
macro      code_cell       i {
    rdtsc
       bt      eax,i and 1Fh
       jc      near $+6 + (i shr 8  and 3Fh - 20h) * code_cell_size
        jnc     near $+6 + (i shr 16 and 3Fh - 20h) * code_cell_size
}
macro finit_code_cell i {
    rdtsc
       bt      eax,i
       jc      near $+6 - (i +    1) * finit_code_cell_size
        jnc     near $+6 - (63-(i*2)) * finit_code_cell_size
}

;define actual code cell sizes now
virtual     at 0
        init_code_cell  0
   init_code_cell_size= $
end virtual
virtual        at 0
        code_cell       0
   code_cell_size= $
end virtual
virtual     at 0
        finit_code_cell 0
   finit_code_cell_size= $
end virtual
;check if all 3 code cell sizes are equal, else code will produce
;unreliable results
if ( init_code_cell_size <> code_cell_size) | \
   (finit_code_cell_size <> code_cell_size)
  display  "ERROR: code cell sizes do not match."
  "ERROR: code cell sizes do not match."
end if

;initialization part
  repeat 31
 init_code_cell  %-1
  end repeat
;random seed:        Uncomment the %t if you're feeling lucky and this will give you
;a different code each time you compile it
  d= 03191BCF4h       ;03197BCF1h     ;%t
  h= d
;main part
  repeat 080h
    h= h + 9E3779B97F4A7C15h            ;~ MAX_INT * (sqrt(5)/2 - 1/2)
    d= ((d shl 43 + d shr 21) xor h) + d;some random random-number function
       code_cell       d
  end repeat
;finitialization part
  repeat 32
   finit_code_cell 32-%
  end repeat
        ret
    

But another problem I see with your suggested code is that it generates jumps out of the code into nowhere (if I'm right), this is mainly because you placed this line:

Code:

  .code_cell_size = $-.current_cell    

after the repeat loop, so that the .code_cell_size is the size of the whole initialization part, and you jump to a multiple (-1 to 30) of this .code_cell_size forward.