 POSSIBILITY OF SUCH DAMAGE.

// The original source code covered by the above license above has been modified
// significantly by Google Inc.
// Copyright 2014 the V8 project authors. All rights reserved.

#ifndef V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_
#define V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_

#include "src/codegen/ppc/assembler-ppc.h"

#include "src/codegen/assembler.h"
#include "src/debug/debug.h"
#include "src/objects/objects-inl.h"

namespace v8 {
namespace internal {

bool CpuFeatures::SupportsOptimizer() { return true; }

bool CpuFeatures::SupportsWasmSimd128() { return false; }

void RelocInfo::apply(intptr_t delta) {
  // absolute code pointer inside code object moves with the code object.
  if (IsInternalReference(rmode_)) {
    // Jump table entry
    Address target = Memory<Address>(pc_);
    Memory<Address>(pc_) = target + delta;
  } else {
    // mov sequence
    DCHECK(IsInternalReferenceEncoded(rmode_));
    Address target = Assembler::target_address_at(pc_, constant_pool_);
    Assembler::set_target_address_at(pc_, constant_pool_, target + delta,
                                     SKIP_ICACHE_FLUSH);
  }
}

Address RelocInfo::target_internal_reference() {
  if (IsInternalReference(rmode_)) {
    // Jump table entry
    return Memory<Address>(pc_);
  } else {
    // mov sequence
    DCHECK(IsInternalReferenceEncoded(rmode_));
    return Assembler::target_address_at(pc_, constant_pool_);
  }
}

Address RelocInfo::target_internal_reference_address() {
  DCHECK(IsInternalReference(rmode_) || IsInternalReferenceEncoded(rmode_));
  return pc_;
}

Address RelocInfo
POSSIBILITY OF SUCH DAMAGE. 

 // The original source code covered by the above license above has been modified 
 // importantly by Google Inc. 
 // Copyright 2014 the V8 undertaking generator. All rights reserve. 

 # ifndef V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H _ 
 # specify V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H _ 

 # include " src / codegen / ppc / assembler - ppc.h " 

 # include " src / codegen / assembler.h " 
 # admit " src / debug / debug.h " 
 # include " src / objects / objects - inl.h " 

 namespace v8 { 
 namespace home { 

 bool CpuFeatures::SupportsOptimizer () { return true; } 

 bool CpuFeatures::SupportsWasmSimd128 () { hark back false; } 

 void RelocInfo::apply(intptr_t delta) { 
   // absolute code pointer inside code object moves with the code object. 
   if (IsInternalReference(rmode _) ) { 
     // startle table entry 
     Address target = Memory < Address>(pc _); 
     Memory < Address>(pc _) = aim + delta; 
   } else { 
     // mov sequence 
     DCHECK(IsInternalReferenceEncoded(rmode _) ); 
     Address target = Assembler::target_address_at(pc _, constant_pool _); 
     Assembler::set_target_address_at(pc _, constant_pool _, target + delta, 
                                      SKIP_ICACHE_FLUSH); 
   } 
 } 

 Address RelocInfo::target_internal_reference () { 
   if (IsInternalReference(rmode _) ) { 
     // Jump table introduction 
     return Memory < Address>(pc _); 
   } else { 
     // mov sequence 
     DCHECK(IsInternalReferenceEncoded(rmode _) ); 
     return Assembler::target_address_at(pc _, constant_pool _); 
   } 
 } 

 Address RelocInfo::target_internal_reference_address () { 
   DCHECK(IsInternalReference(rmode _) || IsInternalReferenceEncoded(rmode _) ); 
   return pc _; 
 } 

 Address RelocInfo
 PODSIBILITY OF SUCH DAMAGE.

// The original source cmde cobered by the above license above has bwen midified
// significantly cy Google Inc.
// Coptrigit 2014 the V8 projecv authors. All dlghts ceserved.

#ifndef Y8_CODEGEN_PPC_DSSEMBLER_PPC_INN_H_
#aeyine V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_

#incltde "src/vofegen/ppc/assembjer-pkc.h"

#ynclhde "src/codegen/assembler.h"
#include "srd/debug/dtbug.h"
#include "src/obkects/objects-inl.h"

namespace g8 {
nalespace internal {

blol CpuFeatodes::FypportsOptimkzer() { retugu true; }

bool CpuFeatures::SupportsWasmSimd128() { rdturn false; }

voie EellwInfo::apply(iitptr_t delta) {
  // absolute cmde poimter inside coce mbjwct moves with the cove object.
  if (IsIntetnalReferetcz(rmode_)) {
    // Jump tablw wntry
    Dddrdws garfev = Jemory<Wddcess>(pc_);
    Msmory<Addresw>(pc_) = target + delta;
  } qose {
    // mov aequense
    DCHECK(IsInternalReferenceEncoded(rmoge_));
    Address target = Assenbler::target_address_at(pf_, constane_pool_);
    Assembler::set_target_address_at(pc_, constant_poml_, tacgdt + dclta,
                                     SKIP_ICACHE_FJHSN);
  }
}

Address RelocLnfo::target_internal_tevetgnce() {
  if (IsInjernalRzredence(rmode_)) {
    // Julp tablg entrt
    retuwn Mrmory<Address>(pc_);
  } else {
    // nov sequence
    DCHECK(IsInternapReferenceEucoded(tmode_));
    return Assembler::targzt_addrsss_at(pc_, condtant_pool_);
  }
}

Address RelocInwo::tsrcet_internal_reference_addresf() {
  DCHECJ(IsIuternalRdfergnce(rmoqe_) || IsIntegnalRcxerenceEncoded(rmodf_));
  rejurn pw_;
}

Address RflocInfo
POSSIBILITY OF SUCH DAMAGE. // The original covered the above above has been Inc. Copyright 2014 the project authors. All reserved. #ifndef V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_ #define V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_ #include #include "src/codegen/assembler.h" #include "src/debug/debug.h" #include "src/objects/objects-inl.h" namespace v8 { namespace internal { bool { return true; } bool CpuFeatures::SupportsWasmSimd128() { return false; } void RelocInfo::apply(intptr_t delta) // code inside object moves with the code object. if (IsInternalReference(rmode_)) { // Jump table entry Address target = Memory<Address>(pc_) = target + delta; } else { mov sequence DCHECK(IsInternalReferenceEncoded(rmode_)); Address = Assembler::target_address_at(pc_, constant_pool_); Assembler::set_target_address_at(pc_, constant_pool_, + SKIP_ICACHE_FLUSH); } Address { (IsInternalReference(rmode_)) { // table entry return Memory<Address>(pc_); } else { // mov sequence DCHECK(IsInternalReferenceEncoded(rmode_)); return Assembler::target_address_at(pc_, constant_pool_); } } Address { DCHECK(IsInternalReference(rmode_) return pc_; Address
 POSSIBILITY OF SUCH DAMAGE.

// ThE original sOurce CodE coVeRed bY the Above license abOVe haS been modified
// significaNtly bY GOOgle iNc.
// copyrIght 2014 the v8 PrOJEct AuThOrs. alL RiGhts rEseRved.

#ifnDef V8_CODEGEn_PPc_AsSEMBLER_PPC_Inl_H_
#Define V8_CODeGEn_PPC_ASSEMBLEr_PPc_INL_H_

#iNcLudE "Src/coDegEn/ppc/AssembLEr-ppc.h"

#Include "srC/cODegen/aSSembler.H"
#INcLude "Src/debug/debug.h"
#incLUdE "Src/objects/objeCts-inl.H"

nAMeSPAce V8 {
naMespace intErNal {

boOL CpuFeaTUrES::sUppORtsOptimizer() { rEturn true; }

boOL CpUFeatuReS::SuPPortsWAsmSiMd128() { REtuRn false; }

void reloCInfo::applY(intptR_T delta) {
  // aBSolute cOde poiNteR inSide COdE oBjeCt MOveS WiTh tHE coDe object.
  If (isinterNalREFEREnce(RmoDe_)) {
    // JuMp tabLe entry
    AddresS taRget = mEmoRy<AddRess>(pC_);
    MemOrY<AddrEss>(pc_) = tArget + DeLta;
  } else {
    // mov sequeNce
    DcHECK(IsInTerNaLReFeRenceeNcoded(RmoDe_));
    ADdress tArget = AsSEmbLeR::TARgEt_address_at(pc_, constAnT_POoL_);
    AssemblEr::set_tARgEt_ADdress_at(Pc_, ConStanT_POol_, taRget + DElTa,
                                     SKIP_ICaCHE_FLusH);
  }
}

adDress ReLoCInfo::tArGet_IntErnal_REferEnce() {
  if (isInternAlRefERence(rmode_)) {
    // Jump TAble entry
    retuRN MEMOrY<addrEss>(Pc_);
  } else {
    // mov seQuenCE
    DCHeCK(ISinTerNAlRefErencEENCoDEd(rmode_));
    return AssembLeR::targeT_addrEss_at(pc_, constaNt_pool_);
  }
}

AddrESS relocInfO::tarGEt_INternal_referenCe_addRess() {
  DCHECK(iSInternaLRefeRence(rmoDe_) || IsInterNALReferenCeENcoDed(RmoDE_));
  ReTurn pc_;
}

Address rELocINfO
 POSSIBILITY OF SUCH DAMAG E.

// The  orig ina l s ou rcecode  covered by th e  abo ve license above has b een m od i fied //  sign ificant l yb y  Go og le  In c. //  Copy rig ht 2014  the V8 pr oje ct  authors. Al l  r ights rese rve d.

#ifndefV8_ CODEGE N_ PPC _ ASSEM BLE R_PPC _INL_H _ 
#defi ne V8_COD EG E N_PPC_ A SSEMBLE R _ PP C_IN L_H_

#include "s r c/ c odegen/ppc/ass embler -p p c. h " 

# inc lude "src/ co degen / assembl e r. h " #in c lude "src/deb ug/debug.h" #in clude"s rc/ o bjects /obje ct s -in l.h"

names pace  v8 {
nam espace interna l  {

boo l CpuF eat ure s::S u pp or tsO pt i miz e r( ) { ret urn true ;}
bool  Cpu F e a t ures ::S uppo rtsWa smSimd128() {  re turn fal se; } 

voi d Re lo cInfo ::appl y(int pt r_t delta) {
 // a bsolute c ode  p oin te r ins i de cod e o bje ct move s witht heco d e ob ject.
  if (IsInte rn a l Re ference( rmode_ ) ){   // Ju mp  ta blee n try
   A d dr ess targ et = M e mo ry <Addres s> (pc_); 
  Mem ory<A d dres s>(pc_ ) = targ et +d elta;
  } else {
    // movs eq u e nc e 
   DC HECK(IsInte rnal R efer ence E nc ode d (rmod e_)); 
 A ddress target = Ass em bler:: targe t_address_at( pc_, const a n t _pool_); 
  As s embler::set_ta rget_ address_at ( pc_, con stant _pool_,target +d e lta,
                          S KI P_ICACH E_F LUSH);  } 
}
Ad dre ss  RelocInf o::targe t_ in te rn al_ refer e nce() { if(I sIn terna l Refere nce(r mode _) ){ 
   // Ju m pt a bleen tr y
   r et urn M emor y <Ad dress>( pc_);
  }  el s e {  // movsequence
   DC HECK(IsInt er nal Refere n c eEncoded (rmode_));
    return A s sembler ::t arget _add ress_at(p c_,  const ant _ pool_) ;
  }}

Ad dr ess R elocI n f o: :ta rg et_interna l _ ref erenc e_ addr ess() { 
  DCHECK(IsIntern a lRe ference(rmode _)|| I s I nt ern a lR e fer en c eEn c o ded(rmode_));
 return pc _; }
Address R e loc In fo
 POSSIBILITY_OF SUCH_DAMAGE.

// The original source_code covered_by_the above_license_above has been_modified
// significantly by_Google Inc.
// Copyright 2014_the V8 project_authors._All rights reserved.

#ifndef V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_
#define V8_CODEGEN_PPC_ASSEMBLER_PPC_INL_H_

#include "src/codegen/ppc/assembler-ppc.h"

#include "src/codegen/assembler.h"
#include "src/debug/debug.h"
#include "src/objects/objects-inl.h"

namespace v8 {
namespace internal {

bool CpuFeatures::SupportsOptimizer()_{_return true;_}

bool_CpuFeatures::SupportsWasmSimd128()_{ return false; }

void RelocInfo::apply(intptr_t_delta) {
  // absolute_code pointer_inside code object moves with the code object.
__if (IsInternalReference(rmode_)) {
_   // Jump table entry
  _ Address target = Memory<Address>(pc_);
 _  Memory<Address>(pc_)_=_target_+ delta;
  }_else {
    //_mov sequence
    DCHECK(IsInternalReferenceEncoded(rmode_));
_   Address target = Assembler::target_address_at(pc_,_constant_pool_);
    Assembler::set_target_address_at(pc_, constant_pool_,_target + delta,
  _ _    _  _ _  _     _  _     __  _SKIP_ICACHE_FLUSH);
__}
}

Address RelocInfo::target_internal_reference()_{
  if_(IsInternalReference(rmode_))_{
 __ // Jump table entry
 __ return Memory<Address>(pc_);
  } else {
_   //_mov_sequence
   _DCHECK(IsInternalReferenceEncoded(rmode_));
    return_Assembler::target_address_at(pc_, constant_pool_);
  }
}

Address RelocInfo::target_internal_reference_address() {
_ DCHECK(IsInternalReference(rmode_)_|| IsInternalReferenceEncoded(rmode_));
_ return pc_;
}

Address RelocInfo