anchor.diff:  is_divisible(_Dividend, 1, SuccLbl, _FailLbl) ->
     [hipe_rtl:mk_goto(SuccLbl)];
   is_divisible(Dividend, Divisor, SuccLbl, FailLbl) ->
  -  Log2 = floorlog2(Divisor),
  +  Log2 = hipe_rtl_binary:floorlog2(Divisor),
     case Divisor =:= 1 bsl Log2 of
       true -> %% Divisor is a power of 2
         %% Test that the Log2-1 lowest bits are clear
  
positive.code:   ProcBinValTag = {proc_bin, val},
    ProcBinBytesTag = {proc_bin, bytes},
    BinOrigSizeTag = {binary, orig_size},
    [get_field_from_term(ProcBinSizeTag, ProcBin, PBSize),
     hipe_rtl:mk_alu(Tmp, SizeReg, 'add', ?LOW_BITS),
     hipe_rtl:mk_alu(ByteSize, Tmp, 'srl', ?BYTE_SHIFT),
     hipe_rtl:mk_alu(ResultingSize, ByteSize, 'add', PBSize),
     set_field_from_term(ProcBinSizeTag, ProcBin, ResultingSize),
     get_field_from_term(ProcBinFlagsTag, ProcBin, Flags),
     hipe_rtl:mk_alu(Flags, Flags, 'or', hipe_rtl:mk_imm(?PB_ACTIVE_WRITER)),
     set_field_from_term(ProcBinFlagsTag, ProcBin, Flags),
     get_field_from_term(ProcBinValTag, ProcBin, BinPointer),
     get_field_from_pointer(BinOrigSizeTag, BinPointer, OrigSize),
     hipe_rtl:mk_branch(OrigSize, 'ltu', ResultingSize,
  		      ReallocLblName, NoReallocLblName),
     NoReallocLbl,
     get_field_from_term(ProcBinBytesTag, ProcBin, Base),
     hipe_rtl:mk_goto(ContLblName),
     ReallocLbl,
     hipe_rtl:mk_alu(NewSize, ResultingSize, 'sll', hipe_rtl:mk_imm(1)),
     hipe_rtl:mk_call([BinPointer], bs_reallocate, [BinPointer, NewSize], 
  		    NextLblName, [], not_remote),
     NextLbl,
     set_field_from_pointer(BinOrigSizeTag, BinPointer, NewSize),
     set_field_from_term(ProcBinValTag, ProcBin, BinPointer),
     hipe_tagscheme:extract_binary_bytes(BinPointer, Base),
     set_field_from_term(ProcBinBytesTag, ProcBin, Base),
     ContLbl].
  
  calculate_sizes(Bin, SizeReg, Offset, EndSubSize, EndSubBitSize) ->
    [SubSize, SubBitSize, EndSize] = create_regs(3),
    [get_field_from_term({sub_binary, binsize}, Bin, SubSize),
     get_field_from_term({sub_binary, bitsize}, Bin, SubBitSize),
     hipe_rtl:mk_alu(Offset, SubSize, 'sll', ?BYTE_SHIFT),
     hipe_rtl:mk_alu(Offset, Offset, 'add', SubBitSize),
     hipe_rtl:mk_alu(EndSize, Offset, 'add', SizeReg),
  
negative.code: 		[NewOffset] = get_real(Dst),
  		case Args of
  		  [Src, Base, Offset] ->
  		    put_static_binary(NewOffset, Src, Size, Base, Offset,
  				      TrueLblName, FalseLblName);
  		  [Src, Bits, Base, Offset]  ->
  		    {SizeCode, SizeReg} =
  		      hipe_rtl_binary:make_size(Size, Bits, SystemLimitLblName,
  						FalseLblName),
  		    InCode = put_dynamic_binary(NewOffset, Src, SizeReg, Base,
  						Offset, TrueLblName, FalseLblName),
  		    SizeCode ++ InCode
  		end
  	    end;
  
  	  {bs_put_float, Size, Flags, ConstInfo} ->
  	    [NewOffset] = get_real(Dst),
  	    Aligned = aligned(Flags),
  	    LittleEndian = littleendian(Flags),
  