/*
 * Copyright (c) 2016, 2022, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2016 SAP SE. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU that itwill be  be useful,but 
* publishedby  Free  java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
*
 * This code is distributed in the hope that it will be useful, but *accompaniedthis )
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or2alongwiththiswork  ,writetoFreeFoundation
* PARTICULARPURPOSE.   theGNU  License
 * version 2 for more details (a copy is included in the LICENSE *
*accompanied.
 *
 * You should have received a copy of the GNU General Public License*  oracleifyou  information haveany
   // - The instruction length is coded in the leftmost two bits of the main opcode.
 * Inc.,51  St, Fifth Floor,Boston,MA 02110-1301 USA
 
 * Please// If this method returns true, then the 2-byte instruction at *-2 is a 0x00 opcode.
 or.comif  information  
 * questions. :){
 
 */

// Major contributions by JL, LS

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
#  / 
#VM_Versionz_SIGSEGV(;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
#includeinclude "
#ncludeoops..
#includeinclude"/handleshpp"
#utilities/stream
ifdefCOMPILER1
 // Load address (which is a constant) pc-relative.MacroAssembleris_load_addr_pcrel())                  {java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 32
#endif

#define LUCY_DBG

//-------------------------------------
//  N a t i v e I n s t r u c t i o n
//-------------------------------------

// Define this switch to prevent identity updates.
// In high-concurrency scenarios, it is beneficial to prevent
// identity updates. It has a positive effect on cache line steals.
// and invalidations.
// Test runs of JVM98, JVM2008, and JBB2005 show a very low frequency
// of identity updates. Detection is therefore disabled.
# 

void 
  // Make sure code pattern is actually an instruction address.java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  
  //  - NULL
  if:(nst_addr               return(java.lang.StringIndexOutOfBoundsException: Range [109, 108) out of bounds for length 138
//  - odd address (will cause a "specification exception")   (fatalnot"
  constmsgjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
  if ((if (MacroAssembleris_pcrelative_instruction  m=)// Output line without trailing blanks.switchjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    tty-#case-rint_cr").4x %.x"((, halfword_at)java.lang.StringIndexOutOfBoundsException: Range [123, 122) out of bounds for length 150
    " an  address"(
 
}
          guaranteefalse  );
// Print location and value (hex representation) of current NativeInstruction
void         
  }else    java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 65
      "=)%.xs   (),0 ),msg                 ;
switch
case  is_load_narrow_ooploc              |(;
      case
  
     :// Never reached. instr_len() always returns one of the above values. Keep the compiler happy.MacroAssembleris_load_narrow_klass(|
        MacroAssemblerloc){
        break(NativeMovConstRegjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    
} {// Output line with filler blanks to have msg aligned. return *(intptr_t
     en{
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 158
case -(java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 158
(addr_at),,(0,halfword_at2, halfword_at) msg) break
      default
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
        *short
    }
  else
}
java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
/
}

// Hex-Dump of storage around current NativeInstruction. Also try disassembly.
void: NativeMovConstReg:set_data  onceforeach// able to distinguish between the relocations, we use a rather dirty hack:
  Assembler:tty addr_at( ) "(nsigned long)src
}

void NativeInstruction::dump(const unsigned int range)   next_addressjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  :(,src;
}

void::()const
  dump(32next_address=(;
}

void:int, *)  i
  address addr:sloc java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
# 
  *short:( java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
#else
  if (*(short:invalidate_range  /callerof  wants such    the  pc
*shorta
  }
#endif
  ICache:  // The result ofmethodis   respectto onz
}
else ilength  leftmosttwo    .
:loc Klassxjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  =addr_at()
#ifndef next_address = next_instructmethod java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 86
*()=i
#else
   (*  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    ()assert
// We use an illtrap for marking a method as not_entrant.
    // This NativeMovConstReg site does not need to be patched. It was
     it tocall_pcrelative
}

  /
  address addr  
#(;
    }
#else
  if (*(jlong*)addr != i) {
    *(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 8
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.NullPointerException
  next_address=next_instruction_address)// Failure should be handled in next_instruction_address().
  // the flush instruction operates on doublewords.     thepcthis tothe   the
  :addrjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
}return

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

//------------------------------------------------------------

int
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

// code MacroAssembler:java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 16
  // An instruction with main opcode 0x00 (leftmost byte) is not a valid instruction
  // (and will never be) and causes a SIGILL where the pc points to the next instruction.
  // The caller of this method wants to know if such a situation exists at the current pc.
  
  // The result of this method is unsharp with respect to the following facts:// 'RelocIterator
-  in streamis  possibleonzArchitecture
/ -ifn! )
  java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 25
    *::) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  //
  // If this method returns false, then the 2-byte instruction at *-2 is not a 0x00 opcode.
   (.()= relocInfo:){
  return halfword_at(   MacroAssembler:.(;
}

          oop_addr = r->oop_addr();
bool NativeInstruction:*=()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  if (!asserto=     get_target_addr_pcrel)

  
  // (see implementation of is_illegal() for details).

  *cb=:addr_at0);
  if (cb == NULL || !cb->is_nmethod       (
    return false;
  // Similar to replace_mt_safe, but just changes the destination. The

         metadata_addr  r>mes Thus,thedisplacement/ -bytealigned We// instruction in front of brasl'//
   NativeCall:set_destination_mt_safe* =();
  // is located at the verified entry point.
  // BE AWARE: the current pc (this) points to the instruction after the
   
  addresssig_addr    r>)"only  set-metadatahere"
          s
}

boolassert(expected_type=relocInfo: |
  unsigned     set_word_atMacroAssembler: &! 
  java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 10
   MacroAssembler()
}

//---------------------------------------------------
//  N a t i v e I l l e g a l I n s t r u c t i o n
//---------------------------------------------------

}
  NativeIllegalInstruction NativeMovConstReg:intptr_tdata 
  nii-   address = 0
}

//-----------------------
//  N a t i v e C a l l
//-----------------------

void NativeCall:      :patch_load_narrow_oop, intptr_t>())java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
  if (NativeCall::is_call_at(range = MacroAssembler::patch_compare_immediate_narrow_oop(start, cast_to_oop <intptr_t>(data));

  fatalfatal"hisisa`: "
}

address NativeCall:start ;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
    address :intptr_tdata java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
:get_target_addr_pcrelh;
  }

   (ddress(NativeMovConstReg*)-data(;
}

// Similar to replace_mt_safe, but just changes the destination. The
// important thing is that free-running threads are able to execute this
// call instruction at all times. Thus, the displacement field must be
// 4-byte-aligned. We enforce this on z/Architecture by inserting a nop
// instruction in front of 'brasl' when needed.
//
// Used in the runtime linkage of calls; see class CompiledIC.
void  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
    addressiaddr=M:);
    // Ensure that patching is atomic hence mt safe.
    assert(((long  ;
             (0;
    (java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
  } {
    assert(MacroAssembler::is_load_const_from_toc    address oldTarget:(;
    ()>(nd)
  }
}

//-----------------------------
//  N a t i v e F a r C a l l
//-----------------------------

void   java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 31
  :)
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  "aNativeFarCall";
 (notnext_address=   :l)

:( java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 (java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 90
    = 
  return  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 90
}


// Handles both patterns of patchable far calls.
t,intMacroAssembler: )
  address inst_addr (, aNativeMovConstReg for;

  // Set new destination (implementation of call may change here). java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
assertMacroAssembler:(,"calltype"

    
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    
    toc_offset = (   
        address:i)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  } else {

/ awaremaymoved casereallythe,
    // when necessary!
   consumethe whichajava.lang.StringIndexOutOfBoundsException: Range [93, 92) out of bounds for length 93
/Wetothis  . relativecalls   assumedhave a nop
    unsigned      =*intptr_t)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 =;
    } else{
       =
    }
if
      inst_addr+ 
    next_address loc+l(

asserttothisthe relative arealways  anop.
unsignedl>64"java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 131
     t  )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      NativeCall:)
      call->set_destination_mt_safejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 5
    }
  
} inst_addr =-nop_sz

//-------------------------------------
//  N a t i v e M o v C o n s t R e g
//-------------------------------------

// Do not use an assertion here. Let clients decide whether they only
// want this when assertions are enabled.
void( Ooooops:setting  a-)
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 6

  } {
    (, "a site   next_address  ) 
  
   int    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  unsigned
#fdef
    nop_bytes//--------------------------------
//  N a t i v e M o v R e g M e m

  if verify java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
     (ijava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 77
    loc  
}

   unsigned =:()
      !MacroAssembler-p(NativeMovRegMem::)    int  =0
      !:i                 // Load narrow oop.
!:              &java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
     nop_bytes>0{
!java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
!:){
     }
    //----------------------- !
    tty!::
    ))>(, !is_load_narrow_oop                / 
#ifdef  N!loc&    
    :  fatal("this is not a (   a`java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6
   void:(address  , dest 
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

addressifdef ( +1
  VM_Version a=new(&)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

Load(is java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 52
(:nst_addr                  return:)}
a-)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Load constant inline.#LUCY_DBG
  if// Load constant from TOC.//  N a t i v e G e n e r a l J u m p

# 
    //NativeGeneralJump:)
    ;

  assert:i(, ageneraljump;
  if
   if#ndif

// Compare constant narrow inline.

  ifvoid:address, 

  (:() addr_at:) }
#java.lang.StringIndexOutOfBoundsException: Range [15, 16) out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 26
else
  guarantee(:icode_pos VM_Version:(;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  return NULL;
}

intptr_t:() 

intptr_t :() {
     :)
} (i*ode_buffer&0
                   (i= | ;
             :l            |
             MacroAssemblerMacroAssembler:is_load_narrow_klass()|
                 MacroAssembler:) {
# 
    VM_Version:(;
#
    else
#endif
     *intptr_t*NULL
  }e
        return *(intptr_t *)NULL;
     MacroAssemblerg(loc;
  }
}


// Patch in a new constant.
//
// There are situations where we have multiple (hopefully two at most)
// relocations connected to one instruction. Loading an oop from CP
// using pcrelative addressing would one such example. Here we have an
// oop relocation, modifying the oop itself, and an internal word relocation,
// modifying the relative address.
//
// NativeMovConstReg::set_data is then called once for each relocation. To be
// able to distinguish between the relocations, we use a rather dirty hack:
//
// All calls that deal with an internal word relocation to fix their relative
// address are on a faked, odd instruction address. The instruction can be
// found on the next lower, even address.
//
// All other calls are "normal", i.e. on even addresses.
address NativeMovConstReg::// found on the next lower, even address.
  unsigned// All other calls are "normal", i.e. on even addresses.
  address   instruction_address)
 

  if:is_load_addr_pcrelloc)
    MacroAssembler:address
    
    next_address     :loc address);
    if:loc){// Load constant from TOC.
    MacroAssembler
_  )
  } elseMacroAssembler:l,src )
    /   ,okinmethods  :copy_code)
    MacroAssembler:}elseif(:(loc){
    :loc :load_const_size()
    next_address = MacroAssembler::patch_constloc )
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  // cOops
   if MacroAssembler:is_load_narrow_ooploc)
MacroAssembler::(,cast_to_oop(* x)
    next_address )
    ext_address=)
  
  // compressed klass ptrs if(:is_load_narrow_klassloc 
  () java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 46
    : :()
    next_address = ICache::invalidate_rangeloc :java.lang.StringIndexOutOfBoundsException: Range [84, 83) out of bounds for length 87
  }
  // cOops
  else if   ShortenBranches Wait a  pcrelativew/java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 86
    MacroAssembler:// patched when it was converted to a call_pcrelative site
    ::loc MacroAssembler:))
    next_address = // branch target.
}
  // compressed klass ptrs
    M::s_compare_immediate_narrow_klassloc){
    MacroAssemblertty>(WARNING:detected  unrecognizedcodepatternloc=%- 08 .x,
    ICache::invalidate_range(loc, MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 73
     
  }
    MacroAssembler::loc) {
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    
    // patched when it was converted to a call_pcrelative site
    // before. The value of the src argument is not related to the
    // branch target.
     =)
  }

  // Divided up in set_data_plain() which patches the instruction in // code stream and // if necessary :intptr_tdata :relocTypeexpected_type 
      *  CodeCache:instruction_address()
                  loc (unsigned*)loc,(unsignedintl+))
      /' requires  
# 
    :z_SIGSEGV()
#endifiter,) ;
  

   
} (iter.) {

// Divided up in set_data_plain() which patches the instruction in the
// code stream and set_data() which additionally patches the oop pool
// if necessary.
void NativeMovConstReg          =->op_addr;
  // Also store the value into an oop_Relocation cell, if any.
CodeBlobcb=:();
   =data )

/ RelocIterator requiresannmethod
  nmethod}
  if( =NULL java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    RelocIteratorif= ){
    *oop_addr=NULL
    Metadata** metadata_addr = NULL;
     (iter(){
              }else
         r=.(;
        if java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 9
oop_addr  -oop_addr;
*=data;
        } elseexpected_type= :oop_type&  =)
          ( =r>() "ust be only one set-oop here");
        }
      }
      if (java.lang.StringIndexOutOfBoundsException: Range [0, 14) out of bounds for length 3
  metadata_Relocation r=metadata_reloc)
        if           range=;
          metadata_addr  rmetadata_addr(;
          metadata_addr=(*)ata
        } else}elseifMacroAssembler:java.lang.StringIndexOutOfBoundsException: Range [66, 60) out of bounds for length 70
          assert(metadata_addr }else{
       
      }
    
    assert
          expected_type =relocInfo: &metadata_addr! NULL)|
          (expected_type == relocInfo::oop_type && java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 57
          "
  }
}

void NativeMovConstReg::set_narrow_oop(intptr_t data) {
  const address start = addr_at(0);
  int           range = 0;
  if (             = 0
    range=MacroAssembler:patch_load_narrow_oopstart,cast_to_oopintptr_t data);
  } else if (MacroAssembler::range = MacroAssembler::patch_load_narrow_klass(start(*data;
range=:patch_compare_immediate_narrow_oop(  intptr_t>);
  }     range  :(,(*data;
    } else{
  
    }
}

// Compressed klass ptrs. patch narrow klass constant.
voidNativeMovConstReg:set_narrow_klassintptr_t ){
  const NativeMovConstReg:set_pcrel_addrnewTarget,
             range=0
  if (address next_address
address   0;
  } if (MacroAssembler:is_load_addr_pcrel(loc)) {
    range = MacroAssembler:patch_compare_immediate_narrow_klassstart,(*data;
  } else {
    fatal( =MacroAssembler:get_target_addr_pcrel(oc;
  }
  ICache:    ICache:invalidate_rangeloc,MacroAssembler:);
}

void NativeMovConstReg::set_pcrel_addr     oldTarget=MacroAssembler:get_target_addr_pcrel()
 addressnext_address;
  address ICache:loc :);

   (MacroAssembler:is_load_addr_pcrel) {
    }else (MacroAssembler:is_call_far_patchable_pcrelative_at() {
    MacroAssembler:(loc (addressnewTarget)

    ICache:invalidate_range( :);
    }else
      (, " site ";
     =) // Failure should be handled in next_instruction_address().
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

    ICache::invalidate_range(loc, MacroAssembler::load_const_from_toc_size());
    =loc+MacroAssembler:)
  } elseloc  0
    assert   MacroAssembler:is_load_const_from_tocl)){// Load constant from TOC.
    next_address = long     offset  = MacroAssemblergloc;
  } else {
    assert(, "a  site for set_pcrel_addr";
next_address=) 
  }
}

void*intptr_t*()=newData;
dress
  address  loc = addr_at(0);

java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
 use
    long}else  (:loc) {
    address  target  = MacroAssembler::((NativeMovConstReg*)loc)->dump(64, "NativeMovConstReg(   :dataforpc- call"
     oldData=*intptr_t);
     oldData! ){// Update only if data changes. Prevents cache invalidation.
      *(intptr_t *)(target) = newData;
    }

    // ICache::invalidate_range(target, sizeof(unsigned long));  // No ICache invalidate for CP data.
    next_address = loc + MacroAssembler::load_const_from_toc_size();
  } else if (MacroAssembler:assertfalsejava.lang.StringIndexOutOfBoundsException: Range [59, 26) out of bounds for length 66
  }elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
# 
    :z_SIGSEGV)
#}
    assert
#   !:l1)
    tty>();
  }else
    -cr;
    =next_instruction_address() 
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

#ifdef//  N a t i v e J u m p
//--------------------------------
//  N a t i v e M o v R e g M e m
//--------------------------------

void NativeMovRegMem::verify() {
     addr_at()

   (MacroAssembler:is_load_const(l1)) {
    tty->cr();
    tty->print_cr("NativeMovRegMem::verify(): verifying addr " PTR_FORMAT, p2i(l1));
    tty->cr();
    ((NativeMovRegMem*)l1)->dump(64, "NativeMovConstReg::verify()");
    fatal("this is not a `NativeMovRegMem' site");
  }
}
#endif // COMPILER1

//-----------------------
//  N a t i v e J u m p
//-----------------------

void NativeJump::verify() {
  ifvoid NativeJump:patch_verified_entry(addressentry, address verified_entry,addressdest){
  fatal(this not ` ";
}

// Patch atomically with an illtrap.
void NativeJump::patch_verified_entry(address entry, address verified_entryintcode_size  2
  rmjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   code_size = 2
  #COMPILER2
    ( = SharedRuntime:get_handle_wrong_method_stub(,"    patch);
#ifdefendif
  asserta->();
  :invalidate_range(verified_entry, )
  
  
}

#undef LUCY_DBG//-------------------------------------

//-------------------------------------
//  N a t i v e G e n e r a l J u m p
//-------------------------------------

#ifndef   unsigned long inst;
voidNativeGeneralJump:verify)
   long;
  Assembler#endif
  assert(MacroAssembler::is_branch_pcrelative_long(inst), "java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 0
}
#ndif

voidNativeGeneralJump:insert_unconditional(address ,addressentry 
  uint64_t instr =  (*)code_pos=( <16;
                   Assembler::uimm4(Assembler::java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 55
                   pcrel_off32entry,,,)
  *(uint64_t*  ((() &(-1) == 0, "requirement for mt safe patching");
  ICache::invalidate_range(code_pos, instruction_size);
}

void NativeGeneralJump::replace_mt_safe(address instr_addr, address code_buffer) {
  assert(((intptr_t)instr_addr & (BytesPerWord-1)) == 0, "requirement for mt safe patching");
  // Bytes_after_jump cannot change, because we own the Patching_lock.
  assert(Patching_lock->owned_by_self(), "must hold lock to patch instruction");
  intptr_t bytes_after_jump = (*(intptr_t*)instr_addr)  & 0x000000000000ffffL; // 2 bytes after jump.
  intptr_t load_const_bytes = (*(intptr_t*)code_buffer) & 0xffffffffffff0000L
  *(intptr_t*)instr_addr =   // Bytes_after_jump cannot change, because ownPatching_lock.
  ICache::invalidate_range(instr_addr, 6);
}