Use Rotate*() functions instead of doing this manually.

src/ppc/simulator-ppc.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdarg.h>
 #include <stdlib.h>
 #include <cmath>
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_PPC
 
 #include "src/assembler.h"
+#include "src/base/bits.h"
 #include "src/codegen.h"
 #include "src/disasm.h"
 #include "src/ppc/constants-ppc.h"
 #include "src/ppc/frames-ppc.h"
 #include "src/ppc/simulator-ppc.h"
 
 #if defined(USE_SIMULATOR)
 
 // Only build the simulator if not compiling for real PPC hardware.
 namespace v8 {
@@ skipping 2967 matching lines @@
 void Simulator::ExecuteExt5(Instruction* instr) {
   switch (instr->Bits(4, 2) << 2) {
     case RLDICL: {
       int ra = instr->RAValue();
       int rs = instr->RSValue();
       uintptr_t rs_val = get_register(rs);
       int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
       int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
       DCHECK(sh >= 0 && sh <= 63);
       DCHECK(mb >= 0 && mb <= 63);
-      // rotate left
-      uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+      uintptr_t result = base::bits::RotateLeft64(rs_val, sh);
       uintptr_t mask = 0xffffffffffffffff >> mb;
       result &= mask;
       set_register(ra, result);
       if (instr->Bit(0)) {  // RC bit set
         SetCR0(result);
       }
       return;
     }
     case RLDICR: {
       int ra = instr->RAValue();
       int rs = instr->RSValue();
       uintptr_t rs_val = get_register(rs);
       int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
       int me = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
       DCHECK(sh >= 0 && sh <= 63);
       DCHECK(me >= 0 && me <= 63);
-      // rotate left
-      uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+      uintptr_t result = base::bits::RotateLeft64(rs_val, sh);
       uintptr_t mask = 0xffffffffffffffff << (63 - me);
       result &= mask;
       set_register(ra, result);
       if (instr->Bit(0)) {  // RC bit set
         SetCR0(result);
       }
       return;
     }
     case RLDIC: {
       int ra = instr->RAValue();
       int rs = instr->RSValue();
       uintptr_t rs_val = get_register(rs);
       int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
       int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
       DCHECK(sh >= 0 && sh <= 63);
       DCHECK(mb >= 0 && mb <= 63);
-      // rotate left
-      uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+      uintptr_t result = base::bits::RotateLeft64(rs_val, sh);
       uintptr_t mask = (0xffffffffffffffff >> mb) & (0xffffffffffffffff << sh);
       result &= mask;
       set_register(ra, result);
       if (instr->Bit(0)) {  // RC bit set
         SetCR0(result);
       }
       return;
     }
     case RLDIMI: {
       int ra = instr->RAValue();
       int rs = instr->RSValue();
       uintptr_t rs_val = get_register(rs);
       intptr_t ra_val = get_register(ra);
       int sh = (instr->Bits(15, 11) | (instr->Bit(1) << 5));
       int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
       int me = 63 - sh;
-      // rotate left
-      uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+      uintptr_t result = base::bits::RotateLeft64(rs_val, sh);
       uintptr_t mask = 0;
       if (mb < me + 1) {
         uintptr_t bit = 0x8000000000000000 >> mb;
         for (; mb <= me; mb++) {
           mask |= bit;
           bit >>= 1;
         }
       } else if (mb == me + 1) {
         mask = 0xffffffffffffffff;
       } else {                                           // mb > me+1
@@ skipping 18 matching lines @@
     case RLDCL: {
       int ra = instr->RAValue();
       int rs = instr->RSValue();
       int rb = instr->RBValue();
       uintptr_t rs_val = get_register(rs);
       uintptr_t rb_val = get_register(rb);
       int sh = (rb_val & 0x3f);
       int mb = (instr->Bits(10, 6) | (instr->Bit(5) << 5));
       DCHECK(sh >= 0 && sh <= 63);
       DCHECK(mb >= 0 && mb <= 63);
-      // rotate left
-      uintptr_t result = (rs_val << sh) | (rs_val >> (64 - sh));
+      uintptr_t result = base::bits::RotateLeft64(rs_val, sh);
       uintptr_t mask = 0xffffffffffffffff >> mb;
       result &= mask;
       set_register(ra, result);
       if (instr->Bit(0)) {  // RC bit set
         SetCR0(result);
       }
       return;
     }
   }
   UNIMPLEMENTED();  // Not used by V8.
@@ skipping 154 matching lines @@
       break;
     }
     case RLWIMIX: {
       int ra = instr->RAValue();
       int rs = instr->RSValue();
       uint32_t rs_val = get_register(rs);
       int32_t ra_val = get_register(ra);
       int sh = instr->Bits(15, 11);
       int mb = instr->Bits(10, 6);
       int me = instr->Bits(5, 1);
-      // rotate left
-      uint32_t result = (rs_val << sh) | (rs_val >> (32 - sh));
+      uint32_t result = base::bits::RotateLeft32(rs_val, sh);
       int mask = 0;
       if (mb < me + 1) {
         int bit = 0x80000000 >> mb;
         for (; mb <= me; mb++) {
           mask |= bit;
           bit >>= 1;
         }
       } else if (mb == me + 1) {
         mask = 0xffffffff;
       } else {                             // mb > me+1
@@ skipping 21 matching lines @@
       int sh = 0;
       if (opcode == RLWINMX) {
         sh = instr->Bits(15, 11);
       } else {
         int rb = instr->RBValue();
         uint32_t rb_val = get_register(rb);
         sh = (rb_val & 0x1f);
       }
       int mb = instr->Bits(10, 6);
       int me = instr->Bits(5, 1);
-      // rotate left
-      uint32_t result = (rs_val << sh) | (rs_val >> (32 - sh));
+      uint32_t result = base::bits::RotateLeft32(rs_val, sh);
       int mask = 0;
       if (mb < me + 1) {
         int bit = 0x80000000 >> mb;
         for (; mb <= me; mb++) {
           mask |= bit;
           bit >>= 1;
         }
       } else if (mb == me + 1) {
         mask = 0xffffffff;
       } else {                             // mb > me+1
@@ skipping 555 matching lines @@
   uintptr_t* stack_slot = reinterpret_cast<uintptr_t*>(current_sp);
   uintptr_t address = *stack_slot;
   set_register(sp, current_sp + sizeof(uintptr_t));
   return address;
 }
 }
 }  // namespace v8::internal
 
 #endif  // USE_SIMULATOR
 #endif  // V8_TARGET_ARCH_PPC