Skip to content

V
V8
Commit 0a701045 authored by kmillikin@chromium.org's avatar kmillikin@chromium.org
Browse files
Options

Remove the static qualifier from functions in header files. 

This shaves 416+ KB, just under 1% off the size of the debug d8 executable
on Linux (mostly because the CheckHelper functions for assertions were
getting separate copies for each compilation unit).  The difference in
release builds is negligible---a size reduction of 0.1%.

Also, change namespace-level 'static const' variables to remove the static
storage class as it's the default.

R=danno@chromium.org
BUG=
TEST=

Review URL: http://codereview.chromium.org/8680013

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@10083 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent 23c15e49
Hide whitespace changes
Inline Side-by-side
Showing with 346 additions and 351 deletions
include/v8.h
View file @ 0a701045
...@@ -3704,8 +3704,8 @@ class V8EXPORT ActivityControl { // NOLINT ...@@ -3704,8 +3704,8 @@ class V8EXPORT ActivityControl { // NOLINT
namespace internal { namespace internal {
static const int kApiPointerSize = sizeof(void*); // NOLINT const int kApiPointerSize = sizeof(void*); // NOLINT
static const int kApiIntSize = sizeof(int); // NOLINT const int kApiIntSize = sizeof(int); // NOLINT
// Tag information for HeapObject. // Tag information for HeapObject.
const int kHeapObjectTag = 1; const int kHeapObjectTag = 1;
......
src/allocation.h
View file @ 0a701045
// Copyright 2008 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -81,7 +81,7 @@ class AllStatic { ...@@ -81,7 +81,7 @@ class AllStatic {
template <typename T> template <typename T>
static T* NewArray(int size) { T* NewArray(int size) {
T* result = new T[size]; T* result = new T[size];
if (result == NULL) Malloced::FatalProcessOutOfMemory(); if (result == NULL) Malloced::FatalProcessOutOfMemory();
return result; return result;
...@@ -89,7 +89,7 @@ static T* NewArray(int size) { ...@@ -89,7 +89,7 @@ static T* NewArray(int size) {
template <typename T> template <typename T>
static void DeleteArray(T* array) { void DeleteArray(T* array) {
delete[] array; delete[] array;
} }
......
src/api.h
View file @ 0a701045
...@@ -112,7 +112,7 @@ void NeanderObject::set(int offset, v8::internal::Object* value) { ...@@ -112,7 +112,7 @@ void NeanderObject::set(int offset, v8::internal::Object* value) {
} }
template <typename T> static inline T ToCData(v8::internal::Object* obj) { template <typename T> inline T ToCData(v8::internal::Object* obj) {
STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address)); STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
return reinterpret_cast<T>( return reinterpret_cast<T>(
reinterpret_cast<intptr_t>( reinterpret_cast<intptr_t>(
...@@ -121,7 +121,7 @@ template <typename T> static inline T ToCData(v8::internal::Object* obj) { ...@@ -121,7 +121,7 @@ template <typename T> static inline T ToCData(v8::internal::Object* obj) {
template <typename T> template <typename T>
static inline v8::internal::Handle<v8::internal::Object> FromCData(T obj) { inline v8::internal::Handle<v8::internal::Object> FromCData(T obj) {
STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address)); STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address));
return FACTORY->NewForeign( return FACTORY->NewForeign(
reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(obj))); reinterpret_cast<v8::internal::Address>(reinterpret_cast<intptr_t>(obj)));
...@@ -236,7 +236,7 @@ class Utils { ...@@ -236,7 +236,7 @@ class Utils {
template <class T> template <class T>
static inline T* ToApi(v8::internal::Handle<v8::internal::Object> obj) { inline T* ToApi(v8::internal::Handle<v8::internal::Object> obj) {
return reinterpret_cast<T*>(obj.location()); return reinterpret_cast<T*>(obj.location());
} }
...@@ -477,7 +477,7 @@ class HandleScopeImplementer { ...@@ -477,7 +477,7 @@ class HandleScopeImplementer {
}; };
static const int kHandleBlockSize = v8::internal::KB - 2; // fit in one page const int kHandleBlockSize = v8::internal::KB - 2; // fit in one page
void HandleScopeImplementer::SaveContext(Context* context) { void HandleScopeImplementer::SaveContext(Context* context) {
......
src/arm/constants-arm.h
View file @ 0a701045
...@@ -87,22 +87,21 @@ namespace v8 { ...@@ -87,22 +87,21 @@ namespace v8 {
namespace internal { namespace internal {
// Constant pool marker. // Constant pool marker.
static const int kConstantPoolMarkerMask = 0xffe00000; const int kConstantPoolMarkerMask = 0xffe00000;
static const int kConstantPoolMarker = 0x0c000000; const int kConstantPoolMarker = 0x0c000000;
static const int kConstantPoolLengthMask = 0x001ffff; const int kConstantPoolLengthMask = 0x001ffff;
// Number of registers in normal ARM mode. // Number of registers in normal ARM mode.
static const int kNumRegisters = 16; const int kNumRegisters = 16;
// VFP support. // VFP support.
static const int kNumVFPSingleRegisters = 32; const int kNumVFPSingleRegisters = 32;
static const int kNumVFPDoubleRegisters = 16; const int kNumVFPDoubleRegisters = 16;
static const int kNumVFPRegisters = const int kNumVFPRegisters = kNumVFPSingleRegisters + kNumVFPDoubleRegisters;
kNumVFPSingleRegisters + kNumVFPDoubleRegisters;
// PC is register 15. // PC is register 15.
static const int kPCRegister = 15; const int kPCRegister = 15;
static const int kNoRegister = -1; const int kNoRegister = -1;
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// Conditions. // Conditions.
...@@ -371,9 +370,9 @@ enum SoftwareInterruptCodes { ...@@ -371,9 +370,9 @@ enum SoftwareInterruptCodes {
// stop // stop
kStopCode = 1 << 23 kStopCode = 1 << 23
}; };
static const uint32_t kStopCodeMask = kStopCode - 1; const uint32_t kStopCodeMask = kStopCode - 1;
static const uint32_t kMaxStopCode = kStopCode - 1; const uint32_t kMaxStopCode = kStopCode - 1;
static const int32_t kDefaultStopCode = -1; const int32_t kDefaultStopCode = -1;
// Type of VFP register. Determines register encoding. // Type of VFP register. Determines register encoding.
...@@ -391,17 +390,17 @@ enum VFPConversionMode { ...@@ -391,17 +390,17 @@ enum VFPConversionMode {
// This mask does not include the "inexact" or "input denormal" cumulative // This mask does not include the "inexact" or "input denormal" cumulative
// exceptions flags, because we usually don't want to check for it. // exceptions flags, because we usually don't want to check for it.
static const uint32_t kVFPExceptionMask = 0xf; const uint32_t kVFPExceptionMask = 0xf;
static const uint32_t kVFPInvalidOpExceptionBit = 1 << 0; const uint32_t kVFPInvalidOpExceptionBit = 1 << 0;
static const uint32_t kVFPOverflowExceptionBit = 1 << 2; const uint32_t kVFPOverflowExceptionBit = 1 << 2;
static const uint32_t kVFPUnderflowExceptionBit = 1 << 3; const uint32_t kVFPUnderflowExceptionBit = 1 << 3;
static const uint32_t kVFPInexactExceptionBit = 1 << 4; const uint32_t kVFPInexactExceptionBit = 1 << 4;
static const uint32_t kVFPFlushToZeroMask = 1 << 24; const uint32_t kVFPFlushToZeroMask = 1 << 24;
static const uint32_t kVFPNConditionFlagBit = 1 << 31; const uint32_t kVFPNConditionFlagBit = 1 << 31;
static const uint32_t kVFPZConditionFlagBit = 1 << 30; const uint32_t kVFPZConditionFlagBit = 1 << 30;
static const uint32_t kVFPCConditionFlagBit = 1 << 29; const uint32_t kVFPCConditionFlagBit = 1 << 29;
static const uint32_t kVFPVConditionFlagBit = 1 << 28; const uint32_t kVFPVConditionFlagBit = 1 << 28;
// VFP rounding modes. See ARM DDI 0406B Page A2-29. // VFP rounding modes. See ARM DDI 0406B Page A2-29.
...@@ -418,7 +417,7 @@ enum VFPRoundingMode { ...@@ -418,7 +417,7 @@ enum VFPRoundingMode {
kRoundToZero = RZ kRoundToZero = RZ
}; };
static const uint32_t kVFPRoundingModeMask = 3 << 22; const uint32_t kVFPRoundingModeMask = 3 << 22;
enum CheckForInexactConversion { enum CheckForInexactConversion {
kCheckForInexactConversion, kCheckForInexactConversion,
......
src/arm/frames-arm.h
View file @ 0a701045
...@@ -35,22 +35,22 @@ namespace internal { ...@@ -35,22 +35,22 @@ namespace internal {
// The ARM ABI does not specify the usage of register r9, which may be reserved // The ARM ABI does not specify the usage of register r9, which may be reserved
// as the static base or thread register on some platforms, in which case we // as the static base or thread register on some platforms, in which case we
// leave it alone. Adjust the value of kR9Available accordingly: // leave it alone. Adjust the value of kR9Available accordingly:
static const int kR9Available = 1; // 1 if available to us, 0 if reserved const int kR9Available = 1; // 1 if available to us, 0 if reserved
// Register list in load/store instructions // Register list in load/store instructions
// Note that the bit values must match those used in actual instruction encoding // Note that the bit values must match those used in actual instruction encoding
static const int kNumRegs = 16; const int kNumRegs = 16;
// Caller-saved/arguments registers // Caller-saved/arguments registers
static const RegList kJSCallerSaved = const RegList kJSCallerSaved =
1 << 0 | // r0 a1 1 << 0 | // r0 a1
1 << 1 | // r1 a2 1 << 1 | // r1 a2
1 << 2 | // r2 a3 1 << 2 | // r2 a3
1 << 3; // r3 a4 1 << 3; // r3 a4
static const int kNumJSCallerSaved = 4; const int kNumJSCallerSaved = 4;
typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved];
...@@ -60,7 +60,7 @@ int JSCallerSavedCode(int n); ...@@ -60,7 +60,7 @@ int JSCallerSavedCode(int n);
// Callee-saved registers preserved when switching from C to JavaScript // Callee-saved registers preserved when switching from C to JavaScript
static const RegList kCalleeSaved = const RegList kCalleeSaved =
1 << 4 | // r4 v1 1 << 4 | // r4 v1
1 << 5 | // r5 v2 1 << 5 | // r5 v2
1 << 6 | // r6 v3 1 << 6 | // r6 v3
...@@ -72,7 +72,7 @@ static const RegList kCalleeSaved = ...@@ -72,7 +72,7 @@ static const RegList kCalleeSaved =
// When calling into C++ (only for C++ calls that can't cause a GC). // When calling into C++ (only for C++ calls that can't cause a GC).
// The call code will take care of lr, fp, etc. // The call code will take care of lr, fp, etc.
static const RegList kCallerSaved = const RegList kCallerSaved =
1 << 0 | // r0 1 << 0 | // r0
1 << 1 | // r1 1 << 1 | // r1
1 << 2 | // r2 1 << 2 | // r2
...@@ -80,23 +80,22 @@ static const RegList kCallerSaved = ...@@ -80,23 +80,22 @@ static const RegList kCallerSaved =
1 << 9; // r9 1 << 9; // r9
static const int kNumCalleeSaved = 7 + kR9Available; const int kNumCalleeSaved = 7 + kR9Available;
// Double registers d8 to d15 are callee-saved. // Double registers d8 to d15 are callee-saved.
static const int kNumDoubleCalleeSaved = 8; const int kNumDoubleCalleeSaved = 8;
// Number of registers for which space is reserved in safepoints. Must be a // Number of registers for which space is reserved in safepoints. Must be a
// multiple of 8. // multiple of 8.
// TODO(regis): Only 8 registers may actually be sufficient. Revisit. // TODO(regis): Only 8 registers may actually be sufficient. Revisit.
static const int kNumSafepointRegisters = 16; const int kNumSafepointRegisters = 16;
// Define the list of registers actually saved at safepoints. // Define the list of registers actually saved at safepoints.
// Note that the number of saved registers may be smaller than the reserved // Note that the number of saved registers may be smaller than the reserved
// space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters. // space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters.
static const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved; const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved;
static const int kNumSafepointSavedRegisters = const int kNumSafepointSavedRegisters = kNumJSCallerSaved + kNumCalleeSaved;
kNumJSCallerSaved + kNumCalleeSaved;
// ---------------------------------------------------- // ----------------------------------------------------
......
src/arm/macro-assembler-arm.h
View file @ 0a701045
...@@ -39,12 +39,12 @@ namespace internal { ...@@ -39,12 +39,12 @@ namespace internal {
// Static helper functions // Static helper functions
// Generate a MemOperand for loading a field from an object. // Generate a MemOperand for loading a field from an object.
static inline MemOperand FieldMemOperand(Register object, int offset) { inline MemOperand FieldMemOperand(Register object, int offset) {
return MemOperand(object, offset - kHeapObjectTag); return MemOperand(object, offset - kHeapObjectTag);
} }
static inline Operand SmiUntagOperand(Register object) { inline Operand SmiUntagOperand(Register object) {
return Operand(object, ASR, kSmiTagSize); return Operand(object, ASR, kSmiTagSize);
} }
...@@ -1300,12 +1300,12 @@ class CodePatcher { ...@@ -1300,12 +1300,12 @@ class CodePatcher {
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// Static helper functions. // Static helper functions.
static MemOperand ContextOperand(Register context, int index) { inline MemOperand ContextOperand(Register context, int index) {
return MemOperand(context, Context::SlotOffset(index)); return MemOperand(context, Context::SlotOffset(index));
} }
static inline MemOperand GlobalObjectOperand() { inline MemOperand GlobalObjectOperand() {
return ContextOperand(cp, Context::GLOBAL_INDEX); return ContextOperand(cp, Context::GLOBAL_INDEX);
} }
......
src/assembler.h
View file @ 0a701045
...@@ -817,33 +817,33 @@ class PreservePositionScope BASE_EMBEDDED { ...@@ -817,33 +817,33 @@ class PreservePositionScope BASE_EMBEDDED {
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// Utility functions // Utility functions
static inline bool is_intn(int x, int n) { inline bool is_intn(int x, int n) {
return -(1 << (n-1)) <= x && x < (1 << (n-1)); return -(1 << (n-1)) <= x && x < (1 << (n-1));
} }
static inline bool is_int8(int x) { return is_intn(x, 8); } inline bool is_int8(int x) { return is_intn(x, 8); }
static inline bool is_int16(int x) { return is_intn(x, 16); } inline bool is_int16(int x) { return is_intn(x, 16); }
static inline bool is_int18(int x) { return is_intn(x, 18); } inline bool is_int18(int x) { return is_intn(x, 18); }
static inline bool is_int24(int x) { return is_intn(x, 24); } inline bool is_int24(int x) { return is_intn(x, 24); }
static inline bool is_uintn(int x, int n) { inline bool is_uintn(int x, int n) {
return (x & -(1 << n)) == 0; return (x & -(1 << n)) == 0;
} }
static inline bool is_uint2(int x) { return is_uintn(x, 2); } inline bool is_uint2(int x) { return is_uintn(x, 2); }
static inline bool is_uint3(int x) { return is_uintn(x, 3); } inline bool is_uint3(int x) { return is_uintn(x, 3); }
static inline bool is_uint4(int x) { return is_uintn(x, 4); } inline bool is_uint4(int x) { return is_uintn(x, 4); }
static inline bool is_uint5(int x) { return is_uintn(x, 5); } inline bool is_uint5(int x) { return is_uintn(x, 5); }
static inline bool is_uint6(int x) { return is_uintn(x, 6); } inline bool is_uint6(int x) { return is_uintn(x, 6); }
static inline bool is_uint8(int x) { return is_uintn(x, 8); } inline bool is_uint8(int x) { return is_uintn(x, 8); }
static inline bool is_uint10(int x) { return is_uintn(x, 10); } inline bool is_uint10(int x) { return is_uintn(x, 10); }
static inline bool is_uint12(int x) { return is_uintn(x, 12); } inline bool is_uint12(int x) { return is_uintn(x, 12); }
static inline bool is_uint16(int x) { return is_uintn(x, 16); } inline bool is_uint16(int x) { return is_uintn(x, 16); }
static inline bool is_uint24(int x) { return is_uintn(x, 24); } inline bool is_uint24(int x) { return is_uintn(x, 24); }
static inline bool is_uint26(int x) { return is_uintn(x, 26); } inline bool is_uint26(int x) { return is_uintn(x, 26); }
static inline bool is_uint28(int x) { return is_uintn(x, 28); } inline bool is_uint28(int x) { return is_uintn(x, 28); }
static inline int NumberOfBitsSet(uint32_t x) { inline int NumberOfBitsSet(uint32_t x) {
unsigned int num_bits_set; unsigned int num_bits_set;
for (num_bits_set = 0; x; x >>= 1) { for (num_bits_set = 0; x; x >>= 1) {
num_bits_set += x & 1; num_bits_set += x & 1;
......
src/bytecodes-irregexp.h
View file @ 0a701045
// Copyright 2008-2009 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -33,12 +33,12 @@ namespace v8 { ...@@ -33,12 +33,12 @@ namespace v8 {
namespace internal { namespace internal {
static const int BYTECODE_MASK = 0xff; const int BYTECODE_MASK = 0xff;
// The first argument is packed in with the byte code in one word, but so it // The first argument is packed in with the byte code in one word, but so it
// has 24 bits, but it can be positive and negative so only use 23 bits for // has 24 bits, but it can be positive and negative so only use 23 bits for
// positive values. // positive values.
static const unsigned int MAX_FIRST_ARG = 0x7fffffu; const unsigned int MAX_FIRST_ARG = 0x7fffffu;
static const int BYTECODE_SHIFT = 8; const int BYTECODE_SHIFT = 8;
#define BYTECODE_ITERATOR(V) \ #define BYTECODE_ITERATOR(V) \
V(BREAK, 0, 4) /* bc8 */ \ V(BREAK, 0, 4) /* bc8 */ \
......
src/char-predicates-inl.h
View file @ 0a701045
// Copyright 2006-2008 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -52,7 +52,7 @@ inline bool IsLineFeed(uc32 c) { ...@@ -52,7 +52,7 @@ inline bool IsLineFeed(uc32 c) {
} }
static inline bool IsInRange(int value, int lower_limit, int higher_limit) { inline bool IsInRange(int value, int lower_limit, int higher_limit) {
ASSERT(lower_limit <= higher_limit); ASSERT(lower_limit <= higher_limit);
return static_cast<unsigned int>(value - lower_limit) <= return static_cast<unsigned int>(value - lower_limit) <=
static_cast<unsigned int>(higher_limit - lower_limit); static_cast<unsigned int>(higher_limit - lower_limit);
......
src/checks.h
View file @ 0a701045
// Copyright 2006-2008 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -52,10 +52,10 @@ extern "C" void V8_Fatal(const char* file, int line, const char* format, ...); ...@@ -52,10 +52,10 @@ extern "C" void V8_Fatal(const char* file, int line, const char* format, ...);
// Used by the CHECK macro -- should not be called directly. // Used by the CHECK macro -- should not be called directly.
static inline void CheckHelper(const char* file, inline void CheckHelper(const char* file,
int line, int line,
const char* source, const char* source,
bool condition) { bool condition) {
if (!condition) if (!condition)
V8_Fatal(file, line, "CHECK(%s) failed", source); V8_Fatal(file, line, "CHECK(%s) failed", source);
} }
...@@ -70,9 +70,9 @@ static inline void CheckHelper(const char* file, ...@@ -70,9 +70,9 @@ static inline void CheckHelper(const char* file,
// Helper function used by the CHECK_EQ function when given int // Helper function used by the CHECK_EQ function when given int
// arguments. Should not be called directly. // arguments. Should not be called directly.
static inline void CheckEqualsHelper(const char* file, int line, inline void CheckEqualsHelper(const char* file, int line,
const char* expected_source, int expected, const char* expected_source, int expected,
const char* value_source, int value) { const char* value_source, int value) {
if (expected != value) { if (expected != value) {
V8_Fatal(file, line, V8_Fatal(file, line,
"CHECK_EQ(%s, %s) failed\n# Expected: %i\n# Found: %i", "CHECK_EQ(%s, %s) failed\n# Expected: %i\n# Found: %i",
...@@ -83,11 +83,11 @@ static inline void CheckEqualsHelper(const char* file, int line, ...@@ -83,11 +83,11 @@ static inline void CheckEqualsHelper(const char* file, int line,
// Helper function used by the CHECK_EQ function when given int64_t // Helper function used by the CHECK_EQ function when given int64_t
// arguments. Should not be called directly. // arguments. Should not be called directly.
static inline void CheckEqualsHelper(const char* file, int line, inline void CheckEqualsHelper(const char* file, int line,
const char* expected_source, const char* expected_source,
int64_t expected, int64_t expected,
const char* value_source, const char* value_source,
int64_t value) { int64_t value) {
if (expected != value) { if (expected != value) {
// Print int64_t values in hex, as two int32s, // Print int64_t values in hex, as two int32s,
// to avoid platform-dependencies. // to avoid platform-dependencies.
...@@ -105,12 +105,12 @@ static inline void CheckEqualsHelper(const char* file, int line, ...@@ -105,12 +105,12 @@ static inline void CheckEqualsHelper(const char* file, int line,
// Helper function used by the CHECK_NE function when given int // Helper function used by the CHECK_NE function when given int
// arguments. Should not be called directly. // arguments. Should not be called directly.
static inline void CheckNonEqualsHelper(const char* file, inline void CheckNonEqualsHelper(const char* file,
int line, int line,
const char* unexpected_source, const char* unexpected_source,
int unexpected, int unexpected,
const char* value_source, const char* value_source,
int value) { int value) {
if (unexpected == value) { if (unexpected == value) {
V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %i", V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %i",
unexpected_source, value_source, value); unexpected_source, value_source, value);
...@@ -120,12 +120,12 @@ static inline void CheckNonEqualsHelper(const char* file, ...@@ -120,12 +120,12 @@ static inline void CheckNonEqualsHelper(const char* file,
// Helper function used by the CHECK function when given string // Helper function used by the CHECK function when given string
// arguments. Should not be called directly. // arguments. Should not be called directly.
static inline void CheckEqualsHelper(const char* file, inline void CheckEqualsHelper(const char* file,
int line, int line,
const char* expected_source, const char* expected_source,
const char* expected, const char* expected,
const char* value_source, const char* value_source,
const char* value) { const char* value) {
if ((expected == NULL && value != NULL) || if ((expected == NULL && value != NULL) ||
(expected != NULL && value == NULL) || (expected != NULL && value == NULL) ||
(expected != NULL && value != NULL && strcmp(expected, value) != 0)) { (expected != NULL && value != NULL && strcmp(expected, value) != 0)) {
...@@ -136,12 +136,12 @@ static inline void CheckEqualsHelper(const char* file, ...@@ -136,12 +136,12 @@ static inline void CheckEqualsHelper(const char* file,
} }
static inline void CheckNonEqualsHelper(const char* file, inline void CheckNonEqualsHelper(const char* file,
int line, int line,
const char* expected_source, const char* expected_source,
const char* expected, const char* expected,
const char* value_source, const char* value_source,
const char* value) { const char* value) {
if (expected == value || if (expected == value ||
(expected != NULL && value != NULL && strcmp(expected, value) == 0)) { (expected != NULL && value != NULL && strcmp(expected, value) == 0)) {
V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %s", V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %s",
...@@ -152,12 +152,12 @@ static inline void CheckNonEqualsHelper(const char* file, ...@@ -152,12 +152,12 @@ static inline void CheckNonEqualsHelper(const char* file,
// Helper function used by the CHECK function when given pointer // Helper function used by the CHECK function when given pointer
// arguments. Should not be called directly. // arguments. Should not be called directly.
static inline void CheckEqualsHelper(const char* file, inline void CheckEqualsHelper(const char* file,
int line, int line,
const char* expected_source, const char* expected_source,
const void* expected, const void* expected,
const char* value_source, const char* value_source,
const void* value) { const void* value) {
if (expected != value) { if (expected != value) {
V8_Fatal(file, line, V8_Fatal(file, line,
"CHECK_EQ(%s, %s) failed\n# Expected: %p\n# Found: %p", "CHECK_EQ(%s, %s) failed\n# Expected: %p\n# Found: %p",
...@@ -167,12 +167,12 @@ static inline void CheckEqualsHelper(const char* file, ...@@ -167,12 +167,12 @@ static inline void CheckEqualsHelper(const char* file,
} }
static inline void CheckNonEqualsHelper(const char* file, inline void CheckNonEqualsHelper(const char* file,
int line, int line,
const char* expected_source, const char* expected_source,
const void* expected, const void* expected,
const char* value_source, const char* value_source,
const void* value) { const void* value) {
if (expected == value) { if (expected == value) {
V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %p", V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %p",
expected_source, value_source, value); expected_source, value_source, value);
...@@ -182,12 +182,12 @@ static inline void CheckNonEqualsHelper(const char* file, ...@@ -182,12 +182,12 @@ static inline void CheckNonEqualsHelper(const char* file,
// Helper function used by the CHECK function when given floating // Helper function used by the CHECK function when given floating
// point arguments. Should not be called directly. // point arguments. Should not be called directly.
static inline void CheckEqualsHelper(const char* file, inline void CheckEqualsHelper(const char* file,
int line, int line,
const char* expected_source, const char* expected_source,
double expected, double expected,
const char* value_source, const char* value_source,
double value) { double value) {
// Force values to 64 bit memory to truncate 80 bit precision on IA32. // Force values to 64 bit memory to truncate 80 bit precision on IA32.
volatile double* exp = new double[1]; volatile double* exp = new double[1];
*exp = expected; *exp = expected;
...@@ -203,12 +203,12 @@ static inline void CheckEqualsHelper(const char* file, ...@@ -203,12 +203,12 @@ static inline void CheckEqualsHelper(const char* file,
} }
static inline void CheckNonEqualsHelper(const char* file, inline void CheckNonEqualsHelper(const char* file,
int line, int line,
const char* expected_source, const char* expected_source,
double expected, double expected,
const char* value_source, const char* value_source,
double value) { double value) {
// Force values to 64 bit memory to truncate 80 bit precision on IA32. // Force values to 64 bit memory to truncate 80 bit precision on IA32.
volatile double* exp = new double[1]; volatile double* exp = new double[1];
*exp = expected; *exp = expected;
......
src/conversions-inl.h
View file @ 0a701045
...@@ -46,7 +46,7 @@ ...@@ -46,7 +46,7 @@
namespace v8 { namespace v8 {
namespace internal { namespace internal {
static inline double JunkStringValue() { inline double JunkStringValue() {
return BitCast<double, uint64_t>(kQuietNaNMask); return BitCast<double, uint64_t>(kQuietNaNMask);
} }
...@@ -54,7 +54,7 @@ static inline double JunkStringValue() { ...@@ -54,7 +54,7 @@ static inline double JunkStringValue() {
// The fast double-to-unsigned-int conversion routine does not guarantee // The fast double-to-unsigned-int conversion routine does not guarantee
// rounding towards zero, or any reasonable value if the argument is larger // rounding towards zero, or any reasonable value if the argument is larger
// than what fits in an unsigned 32-bit integer. // than what fits in an unsigned 32-bit integer.
static inline unsigned int FastD2UI(double x) { inline unsigned int FastD2UI(double x) {
// There is no unsigned version of lrint, so there is no fast path // There is no unsigned version of lrint, so there is no fast path
// in this function as there is in FastD2I. Using lrint doesn't work // in this function as there is in FastD2I. Using lrint doesn't work
// for values of 2^31 and above. // for values of 2^31 and above.
...@@ -80,7 +80,7 @@ static inline unsigned int FastD2UI(double x) { ...@@ -80,7 +80,7 @@ static inline unsigned int FastD2UI(double x) {
} }
static inline double DoubleToInteger(double x) { inline double DoubleToInteger(double x) {
if (isnan(x)) return 0; if (isnan(x)) return 0;
if (!isfinite(x) || x == 0) return x; if (!isfinite(x) || x == 0) return x;
return (x >= 0) ? floor(x) : ceil(x); return (x >= 0) ? floor(x) : ceil(x);
...@@ -103,9 +103,9 @@ int32_t DoubleToInt32(double x) { ...@@ -103,9 +103,9 @@ int32_t DoubleToInt32(double x) {
template <class Iterator, class EndMark> template <class Iterator, class EndMark>
static bool SubStringEquals(Iterator* current, bool SubStringEquals(Iterator* current,
EndMark end, EndMark end,
const char* substring) { const char* substring) {
ASSERT(**current == *substring); ASSERT(**current == *substring);
for (substring++; *substring != '\0'; substring++) { for (substring++; *substring != '\0'; substring++) {
++*current; ++*current;
...@@ -119,9 +119,9 @@ static bool SubStringEquals(Iterator* current, ...@@ -119,9 +119,9 @@ static bool SubStringEquals(Iterator* current,
// Returns true if a nonspace character has been found and false if the // Returns true if a nonspace character has been found and false if the
// end was been reached before finding a nonspace character. // end was been reached before finding a nonspace character.
template <class Iterator, class EndMark> template <class Iterator, class EndMark>
static inline bool AdvanceToNonspace(UnicodeCache* unicode_cache, inline bool AdvanceToNonspace(UnicodeCache* unicode_cache,
Iterator* current, Iterator* current,
EndMark end) { EndMark end) {
while (*current != end) { while (*current != end) {
if (!unicode_cache->IsWhiteSpace(**current)) return true; if (!unicode_cache->IsWhiteSpace(**current)) return true;
++*current; ++*current;
...@@ -132,11 +132,11 @@ static inline bool AdvanceToNonspace(UnicodeCache* unicode_cache, ...@@ -132,11 +132,11 @@ static inline bool AdvanceToNonspace(UnicodeCache* unicode_cache,
// Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end. // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
template <int radix_log_2, class Iterator, class EndMark> template <int radix_log_2, class Iterator, class EndMark>
static double InternalStringToIntDouble(UnicodeCache* unicode_cache, double InternalStringToIntDouble(UnicodeCache* unicode_cache,
Iterator current, Iterator current,
EndMark end, EndMark end,
bool negative, bool negative,
bool allow_trailing_junk) { bool allow_trailing_junk) {
ASSERT(current != end); ASSERT(current != end);
// Skip leading 0s. // Skip leading 0s.
...@@ -235,10 +235,10 @@ static double InternalStringToIntDouble(UnicodeCache* unicode_cache, ...@@ -235,10 +235,10 @@ static double InternalStringToIntDouble(UnicodeCache* unicode_cache,
template <class Iterator, class EndMark> template <class Iterator, class EndMark>
static double InternalStringToInt(UnicodeCache* unicode_cache, double InternalStringToInt(UnicodeCache* unicode_cache,
Iterator current, Iterator current,
EndMark end, EndMark end,
int radix) { int radix) {
const bool allow_trailing_junk = true; const bool allow_trailing_junk = true;
const double empty_string_val = JunkStringValue(); const double empty_string_val = JunkStringValue();
...@@ -430,11 +430,11 @@ static double InternalStringToInt(UnicodeCache* unicode_cache, ...@@ -430,11 +430,11 @@ static double InternalStringToInt(UnicodeCache* unicode_cache,
// 2. *current - gets the current character in the sequence. // 2. *current - gets the current character in the sequence.
// 3. ++current (advances the position). // 3. ++current (advances the position).
template <class Iterator, class EndMark> template <class Iterator, class EndMark>
static double InternalStringToDouble(UnicodeCache* unicode_cache, double InternalStringToDouble(UnicodeCache* unicode_cache,
Iterator current, Iterator current,
EndMark end, EndMark end,
int flags, int flags,
double empty_string_val) { double empty_string_val) {
// To make sure that iterator dereferencing is valid the following // To make sure that iterator dereferencing is valid the following
// convention is used: // convention is used:
// 1. Each '++current' statement is followed by check for equality to 'end'. // 1. Each '++current' statement is followed by check for equality to 'end'.
......
src/conversions.h
View file @ 0a701045
...@@ -45,14 +45,14 @@ class UnicodeCache; ...@@ -45,14 +45,14 @@ class UnicodeCache;
const int kMaxSignificantDigits = 772; const int kMaxSignificantDigits = 772;
static inline bool isDigit(int x, int radix) { inline bool isDigit(int x, int radix) {
return (x >= '0' && x <= '9' && x < '0' + radix) return (x >= '0' && x <= '9' && x < '0' + radix)
|| (radix > 10 && x >= 'a' && x < 'a' + radix - 10) || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
|| (radix > 10 && x >= 'A' && x < 'A' + radix - 10); || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
} }
static inline double SignedZero(bool negative) { inline double SignedZero(bool negative) {
return negative ? -0.0 : 0.0; return negative ? -0.0 : 0.0;
} }
...@@ -61,16 +61,16 @@ static inline double SignedZero(bool negative) { ...@@ -61,16 +61,16 @@ static inline double SignedZero(bool negative) {
// rounding towards zero. // rounding towards zero.
// The result is unspecified if x is infinite or NaN, or if the rounded // The result is unspecified if x is infinite or NaN, or if the rounded
// integer value is outside the range of type int. // integer value is outside the range of type int.
static inline int FastD2I(double x) { inline int FastD2I(double x) {
// The static_cast convertion from double to int used to be slow, but // The static_cast convertion from double to int used to be slow, but
// as new benchmarks show, now it is much faster than lrint(). // as new benchmarks show, now it is much faster than lrint().
return static_cast<int>(x); return static_cast<int>(x);
} }
static inline unsigned int FastD2UI(double x); inline unsigned int FastD2UI(double x);
static inline double FastI2D(int x) { inline double FastI2D(int x) {
// There is no rounding involved in converting an integer to a // There is no rounding involved in converting an integer to a
// double, so this code should compile to a few instructions without // double, so this code should compile to a few instructions without
// any FPU pipeline stalls. // any FPU pipeline stalls.
...@@ -78,7 +78,7 @@ static inline double FastI2D(int x) { ...@@ -78,7 +78,7 @@ static inline double FastI2D(int x) {
} }
static inline double FastUI2D(unsigned x) { inline double FastUI2D(unsigned x) {
// There is no rounding involved in converting an unsigned integer to a // There is no rounding involved in converting an unsigned integer to a
// double, so this code should compile to a few instructions without // double, so this code should compile to a few instructions without
// any FPU pipeline stalls. // any FPU pipeline stalls.
...@@ -87,15 +87,15 @@ static inline double FastUI2D(unsigned x) { ...@@ -87,15 +87,15 @@ static inline double FastUI2D(unsigned x) {
// This function should match the exact semantics of ECMA-262 9.4. // This function should match the exact semantics of ECMA-262 9.4.
static inline double DoubleToInteger(double x); inline double DoubleToInteger(double x);
// This function should match the exact semantics of ECMA-262 9.5. // This function should match the exact semantics of ECMA-262 9.5.
static inline int32_t DoubleToInt32(double x); inline int32_t DoubleToInt32(double x);
// This function should match the exact semantics of ECMA-262 9.6. // This function should match the exact semantics of ECMA-262 9.6.
static inline uint32_t DoubleToUint32(double x) { inline uint32_t DoubleToUint32(double x) {
return static_cast<uint32_t>(DoubleToInt32(x)); return static_cast<uint32_t>(DoubleToInt32(x));
} }
......
src/double.h
View file @ 0a701045
// Copyright 2010 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -34,8 +34,8 @@ namespace v8 { ...@@ -34,8 +34,8 @@ namespace v8 {
namespace internal { namespace internal {
// We assume that doubles and uint64_t have the same endianness. // We assume that doubles and uint64_t have the same endianness.
static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); } inline uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); }
static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); } inline double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); }
// Helper functions for doubles. // Helper functions for doubles.
class Double { class Double {
......
src/dtoa.h
View file @ 0a701045
// Copyright 2010 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -47,7 +47,7 @@ enum DtoaMode { ...@@ -47,7 +47,7 @@ enum DtoaMode {
// The maximal length of digits a double can have in base 10. // The maximal length of digits a double can have in base 10.
// Note that DoubleToAscii null-terminates its input. So the given buffer should // Note that DoubleToAscii null-terminates its input. So the given buffer should
// be at least kBase10MaximalLength + 1 characters long. // be at least kBase10MaximalLength + 1 characters long.
static const int kBase10MaximalLength = 17; const int kBase10MaximalLength = 17;
// Converts the given double 'v' to ascii. // Converts the given double 'v' to ascii.
// The result should be interpreted as buffer * 10^(point-length). // The result should be interpreted as buffer * 10^(point-length).
......
src/fast-dtoa.h
View file @ 0a701045
// Copyright 2010 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -43,7 +43,7 @@ enum FastDtoaMode { ...@@ -43,7 +43,7 @@ enum FastDtoaMode {
// FastDtoa will produce at most kFastDtoaMaximalLength digits. This does not // FastDtoa will produce at most kFastDtoaMaximalLength digits. This does not
// include the terminating '\0' character. // include the terminating '\0' character.
static const int kFastDtoaMaximalLength = 17; const int kFastDtoaMaximalLength = 17;
// Provides a decimal representation of v. // Provides a decimal representation of v.
// The result should be interpreted as buffer * 10^(point - length). // The result should be interpreted as buffer * 10^(point - length).
......
src/globals.h
View file @ 0a701045
...@@ -294,7 +294,7 @@ const uint32_t kMaxAsciiCharCodeU = 0x7fu; ...@@ -294,7 +294,7 @@ const uint32_t kMaxAsciiCharCodeU = 0x7fu;
// The USE(x) template is used to silence C++ compiler warnings // The USE(x) template is used to silence C++ compiler warnings
// issued for (yet) unused variables (typically parameters). // issued for (yet) unused variables (typically parameters).
template <typename T> template <typename T>
static inline void USE(T) { } inline void USE(T) { }
// FUNCTION_ADDR(f) gets the address of a C function f. // FUNCTION_ADDR(f) gets the address of a C function f.
......
src/hydrogen-instructions.h
View file @ 0a701045
...@@ -3370,7 +3370,7 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> { ...@@ -3370,7 +3370,7 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> {
}; };
static inline bool StoringValueNeedsWriteBarrier(HValue* value) { inline bool StoringValueNeedsWriteBarrier(HValue* value) {
return !value->type().IsBoolean() return !value->type().IsBoolean()
&& !value->type().IsSmi() && !value->type().IsSmi()
&& !(value->IsConstant() && HConstant::cast(value)->ImmortalImmovable()); && !(value->IsConstant() && HConstant::cast(value)->ImmortalImmovable());
......
src/ia32/frames-ia32.h
View file @ 0a701045
...@@ -34,24 +34,24 @@ namespace internal { ...@@ -34,24 +34,24 @@ namespace internal {
// Register lists // Register lists
// Note that the bit values must match those used in actual instruction encoding // Note that the bit values must match those used in actual instruction encoding
static const int kNumRegs = 8; const int kNumRegs = 8;
// Caller-saved registers // Caller-saved registers
static const RegList kJSCallerSaved = const RegList kJSCallerSaved =
1 << 0 | // eax 1 << 0 | // eax
1 << 1 | // ecx 1 << 1 | // ecx
1 << 2 | // edx 1 << 2 | // edx
1 << 3 | // ebx - used as a caller-saved register in JavaScript code 1 << 3 | // ebx - used as a caller-saved register in JavaScript code
1 << 7; // edi - callee function 1 << 7; // edi - callee function
static const int kNumJSCallerSaved = 5; const int kNumJSCallerSaved = 5;
typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved];
// Number of registers for which space is reserved in safepoints. // Number of registers for which space is reserved in safepoints.
static const int kNumSafepointRegisters = 8; const int kNumSafepointRegisters = 8;
// ---------------------------------------------------- // ----------------------------------------------------
......
src/ia32/macro-assembler-ia32.h
View file @ 0a701045
...@@ -881,26 +881,26 @@ class CodePatcher { ...@@ -881,26 +881,26 @@ class CodePatcher {
// Static helper functions. // Static helper functions.
// Generate an Operand for loading a field from an object. // Generate an Operand for loading a field from an object.
static inline Operand FieldOperand(Register object, int offset) { inline Operand FieldOperand(Register object, int offset) {
return Operand(object, offset - kHeapObjectTag); return Operand(object, offset - kHeapObjectTag);
} }
// Generate an Operand for loading an indexed field from an object. // Generate an Operand for loading an indexed field from an object.
static inline Operand FieldOperand(Register object, inline Operand FieldOperand(Register object,
Register index, Register index,
ScaleFactor scale, ScaleFactor scale,
int offset) { int offset) {
return Operand(object, index, scale, offset - kHeapObjectTag); return Operand(object, index, scale, offset - kHeapObjectTag);
} }
static inline Operand ContextOperand(Register context, int index) { inline Operand ContextOperand(Register context, int index) {
return Operand(context, Context::SlotOffset(index)); return Operand(context, Context::SlotOffset(index));
} }
static inline Operand GlobalObjectOperand() { inline Operand GlobalObjectOperand() {
return ContextOperand(esi, Context::GLOBAL_INDEX); return ContextOperand(esi, Context::GLOBAL_INDEX);
} }
......
src/mips/constants-mips.h
View file @ 0a701045
...@@ -50,13 +50,13 @@ ...@@ -50,13 +50,13 @@
#if(defined(__mips_hard_float) && __mips_hard_float != 0) #if(defined(__mips_hard_float) && __mips_hard_float != 0)
// Use floating-point coprocessor instructions. This flag is raised when // Use floating-point coprocessor instructions. This flag is raised when
// -mhard-float is passed to the compiler. // -mhard-float is passed to the compiler.
static const bool IsMipsSoftFloatABI = false; const bool IsMipsSoftFloatABI = false;
#elif(defined(__mips_soft_float) && __mips_soft_float != 0) #elif(defined(__mips_soft_float) && __mips_soft_float != 0)
// Not using floating-point coprocessor instructions. This flag is raised when // Not using floating-point coprocessor instructions. This flag is raised when
// -msoft-float is passed to the compiler. // -msoft-float is passed to the compiler.
static const bool IsMipsSoftFloatABI = true; const bool IsMipsSoftFloatABI = true;
#else #else
static const bool IsMipsSoftFloatABI = true; const bool IsMipsSoftFloatABI = true;
#endif #endif
...@@ -74,46 +74,45 @@ namespace internal { ...@@ -74,46 +74,45 @@ namespace internal {
// Registers and FPURegisters. // Registers and FPURegisters.
// Number of general purpose registers. // Number of general purpose registers.
static const int kNumRegisters = 32; const int kNumRegisters = 32;
static const int kInvalidRegister = -1; const int kInvalidRegister = -1;
// Number of registers with HI, LO, and pc. // Number of registers with HI, LO, and pc.
static const int kNumSimuRegisters = 35; const int kNumSimuRegisters = 35;
// In the simulator, the PC register is simulated as the 34th register. // In the simulator, the PC register is simulated as the 34th register.
static const int kPCRegister = 34; const int kPCRegister = 34;
// Number coprocessor registers. // Number coprocessor registers.
static const int kNumFPURegisters = 32; const int kNumFPURegisters = 32;
static const int kInvalidFPURegister = -1; const int kInvalidFPURegister = -1;
// FPU (coprocessor 1) control registers. Currently only FCSR is implemented. // FPU (coprocessor 1) control registers. Currently only FCSR is implemented.
static const int kFCSRRegister = 31; const int kFCSRRegister = 31;
static const int kInvalidFPUControlRegister = -1; const int kInvalidFPUControlRegister = -1;
static const uint32_t kFPUInvalidResult = (uint32_t) (1 << 31) - 1; const uint32_t kFPUInvalidResult = (uint32_t) (1 << 31) - 1;
// FCSR constants. // FCSR constants.
static const uint32_t kFCSRInexactFlagBit = 2; const uint32_t kFCSRInexactFlagBit = 2;
static const uint32_t kFCSRUnderflowFlagBit = 3; const uint32_t kFCSRUnderflowFlagBit = 3;
static const uint32_t kFCSROverflowFlagBit = 4; const uint32_t kFCSROverflowFlagBit = 4;
static const uint32_t kFCSRDivideByZeroFlagBit = 5; const uint32_t kFCSRDivideByZeroFlagBit = 5;
static const uint32_t kFCSRInvalidOpFlagBit = 6; const uint32_t kFCSRInvalidOpFlagBit = 6;
static const uint32_t kFCSRInexactFlagMask = 1 << kFCSRInexactFlagBit; const uint32_t kFCSRInexactFlagMask = 1 << kFCSRInexactFlagBit;
static const uint32_t kFCSRUnderflowFlagMask = 1 << kFCSRUnderflowFlagBit; const uint32_t kFCSRUnderflowFlagMask = 1 << kFCSRUnderflowFlagBit;
static const uint32_t kFCSROverflowFlagMask = 1 << kFCSROverflowFlagBit; const uint32_t kFCSROverflowFlagMask = 1 << kFCSROverflowFlagBit;
static const uint32_t kFCSRDivideByZeroFlagMask = 1 << kFCSRDivideByZeroFlagBit; const uint32_t kFCSRDivideByZeroFlagMask = 1 << kFCSRDivideByZeroFlagBit;
static const uint32_t kFCSRInvalidOpFlagMask = 1 << kFCSRInvalidOpFlagBit; const uint32_t kFCSRInvalidOpFlagMask = 1 << kFCSRInvalidOpFlagBit;
static const uint32_t kFCSRFlagMask = const uint32_t kFCSRFlagMask =
kFCSRInexactFlagMask | kFCSRInexactFlagMask |
kFCSRUnderflowFlagMask | kFCSRUnderflowFlagMask |
kFCSROverflowFlagMask | kFCSROverflowFlagMask |
kFCSRDivideByZeroFlagMask | kFCSRDivideByZeroFlagMask |
kFCSRInvalidOpFlagMask; kFCSRInvalidOpFlagMask;
static const uint32_t kFCSRExceptionFlagMask = const uint32_t kFCSRExceptionFlagMask = kFCSRFlagMask ^ kFCSRInexactFlagMask;
kFCSRFlagMask ^ kFCSRInexactFlagMask;
// Helper functions for converting between register numbers and names. // Helper functions for converting between register numbers and names.
class Registers { class Registers {
...@@ -177,67 +176,66 @@ enum SoftwareInterruptCodes { ...@@ -177,67 +176,66 @@ enum SoftwareInterruptCodes {
// instructions (see Assembler::stop()). // instructions (see Assembler::stop()).
// - Breaks larger than kMaxStopCode are simple breaks, dropping you into the // - Breaks larger than kMaxStopCode are simple breaks, dropping you into the
// debugger. // debugger.
static const uint32_t kMaxWatchpointCode = 31; const uint32_t kMaxWatchpointCode = 31;
static const uint32_t kMaxStopCode = 127; const uint32_t kMaxStopCode = 127;
STATIC_ASSERT(kMaxWatchpointCode < kMaxStopCode); STATIC_ASSERT(kMaxWatchpointCode < kMaxStopCode);
// ----- Fields offset and length. // ----- Fields offset and length.
static const int kOpcodeShift = 26; const int kOpcodeShift = 26;
static const int kOpcodeBits = 6; const int kOpcodeBits = 6;
static const int kRsShift = 21; const int kRsShift = 21;
static const int kRsBits = 5; const int kRsBits = 5;
static const int kRtShift = 16; const int kRtShift = 16;
static const int kRtBits = 5; const int kRtBits = 5;
static const int kRdShift = 11; const int kRdShift = 11;
static const int kRdBits = 5; const int kRdBits = 5;
static const int kSaShift = 6; const int kSaShift = 6;
static const int kSaBits = 5; const int kSaBits = 5;
static const int kFunctionShift = 0; const int kFunctionShift = 0;
static const int kFunctionBits = 6; const int kFunctionBits = 6;
static const int kLuiShift = 16; const int kLuiShift = 16;
static const int kImm16Shift = 0; const int kImm16Shift = 0;
static const int kImm16Bits = 16; const int kImm16Bits = 16;
static const int kImm26Shift = 0; const int kImm26Shift = 0;
static const int kImm26Bits = 26; const int kImm26Bits = 26;
static const int kImm28Shift = 0; const int kImm28Shift = 0;
static const int kImm28Bits = 28; const int kImm28Bits = 28;
// In branches and jumps immediate fields point to words, not bytes, // In branches and jumps immediate fields point to words, not bytes,
// and are therefore shifted by 2. // and are therefore shifted by 2.
static const int kImmFieldShift = 2; const int kImmFieldShift = 2;
static const int kFsShift = 11; const int kFsShift = 11;
static const int kFsBits = 5; const int kFsBits = 5;
static const int kFtShift = 16; const int kFtShift = 16;
static const int kFtBits = 5; const int kFtBits = 5;
static const int kFdShift = 6; const int kFdShift = 6;
static const int kFdBits = 5; const int kFdBits = 5;
static const int kFCccShift = 8; const int kFCccShift = 8;
static const int kFCccBits = 3; const int kFCccBits = 3;
static const int kFBccShift = 18; const int kFBccShift = 18;
static const int kFBccBits = 3; const int kFBccBits = 3;
static const int kFBtrueShift = 16; const int kFBtrueShift = 16;
static const int kFBtrueBits = 1; const int kFBtrueBits = 1;
// ----- Miscellaneous useful masks. // ----- Miscellaneous useful masks.
// Instruction bit masks. // Instruction bit masks.
static const int kOpcodeMask = ((1 << kOpcodeBits) - 1) << kOpcodeShift; const int kOpcodeMask = ((1 << kOpcodeBits) - 1) << kOpcodeShift;
static const int kImm16Mask = ((1 << kImm16Bits) - 1) << kImm16Shift; const int kImm16Mask = ((1 << kImm16Bits) - 1) << kImm16Shift;
static const int kImm26Mask = ((1 << kImm26Bits) - 1) << kImm26Shift; const int kImm26Mask = ((1 << kImm26Bits) - 1) << kImm26Shift;
static const int kImm28Mask = ((1 << kImm28Bits) - 1) << kImm28Shift; const int kImm28Mask = ((1 << kImm28Bits) - 1) << kImm28Shift;
static const int kRsFieldMask = ((1 << kRsBits) - 1) << kRsShift; const int kRsFieldMask = ((1 << kRsBits) - 1) << kRsShift;
static const int kRtFieldMask = ((1 << kRtBits) - 1) << kRtShift; const int kRtFieldMask = ((1 << kRtBits) - 1) << kRtShift;
static const int kRdFieldMask = ((1 << kRdBits) - 1) << kRdShift; const int kRdFieldMask = ((1 << kRdBits) - 1) << kRdShift;
static const int kSaFieldMask = ((1 << kSaBits) - 1) << kSaShift; const int kSaFieldMask = ((1 << kSaBits) - 1) << kSaShift;
static const int kFunctionFieldMask = const int kFunctionFieldMask = ((1 << kFunctionBits) - 1) << kFunctionShift;
((1 << kFunctionBits) - 1) << kFunctionShift;
// Misc masks. // Misc masks.
static const int kHiMask = 0xffff << 16; const int kHiMask = 0xffff << 16;
static const int kLoMask = 0xffff; const int kLoMask = 0xffff;
static const int kSignMask = 0x80000000; const int kSignMask = 0x80000000;
static const int kJumpAddrMask = (1 << (kImm26Bits + kImmFieldShift)) - 1; const int kJumpAddrMask = (1 << (kImm26Bits + kImmFieldShift)) - 1;
// ----- MIPS Opcodes and Function Fields. // ----- MIPS Opcodes and Function Fields.
// We use this presentation to stay close to the table representation in // We use this presentation to stay close to the table representation in
...@@ -529,7 +527,7 @@ enum FPURoundingMode { ...@@ -529,7 +527,7 @@ enum FPURoundingMode {
kRoundToMinusInf = RM kRoundToMinusInf = RM
}; };
static const uint32_t kFPURoundingModeMask = 3 << 0; const uint32_t kFPURoundingModeMask = 3 << 0;
enum CheckForInexactConversion { enum CheckForInexactConversion {
kCheckForInexactConversion, kCheckForInexactConversion,
...@@ -772,18 +770,18 @@ class Instruction { ...@@ -772,18 +770,18 @@ class Instruction {
// MIPS assembly various constants. // MIPS assembly various constants.
// C/C++ argument slots size. // C/C++ argument slots size.
static const int kCArgSlotCount = 4; const int kCArgSlotCount = 4;
static const int kCArgsSlotsSize = kCArgSlotCount * Instruction::kInstrSize; const int kCArgsSlotsSize = kCArgSlotCount * Instruction::kInstrSize;
// JS argument slots size. // JS argument slots size.
static const int kJSArgsSlotsSize = 0 * Instruction::kInstrSize; const int kJSArgsSlotsSize = 0 * Instruction::kInstrSize;
// Assembly builtins argument slots size. // Assembly builtins argument slots size.
static const int kBArgsSlotsSize = 0 * Instruction::kInstrSize; const int kBArgsSlotsSize = 0 * Instruction::kInstrSize;
static const int kBranchReturnOffset = 2 * Instruction::kInstrSize; const int kBranchReturnOffset = 2 * Instruction::kInstrSize;
static const int kDoubleAlignmentBits = 3; const int kDoubleAlignmentBits = 3;
static const int kDoubleAlignment = (1 << kDoubleAlignmentBits); const int kDoubleAlignment = (1 << kDoubleAlignmentBits);
static const int kDoubleAlignmentMask = kDoubleAlignment - 1; const int kDoubleAlignmentMask = kDoubleAlignment - 1;
} } // namespace v8::internal } } // namespace v8::internal
......
src/mips/frames-mips.h
View file @ 0a701045
...@@ -36,9 +36,9 @@ namespace internal { ...@@ -36,9 +36,9 @@ namespace internal {
// Register lists. // Register lists.
// Note that the bit values must match those used in actual instruction // Note that the bit values must match those used in actual instruction
// encoding. // encoding.
static const int kNumRegs = 32; const int kNumRegs = 32;
static const RegList kJSCallerSaved = const RegList kJSCallerSaved =
1 << 2 | // v0 1 << 2 | // v0
1 << 3 | // v1 1 << 3 | // v1
1 << 4 | // a0 1 << 4 | // a0
...@@ -54,7 +54,7 @@ static const RegList kJSCallerSaved = ...@@ -54,7 +54,7 @@ static const RegList kJSCallerSaved =
1 << 14 | // t6 1 << 14 | // t6
1 << 15; // t7 1 << 15; // t7
static const int kNumJSCallerSaved = 14; const int kNumJSCallerSaved = 14;
// Return the code of the n-th caller-saved register available to JavaScript // Return the code of the n-th caller-saved register available to JavaScript
...@@ -63,7 +63,7 @@ int JSCallerSavedCode(int n); ...@@ -63,7 +63,7 @@ int JSCallerSavedCode(int n);
// Callee-saved registers preserved when switching from C to JavaScript. // Callee-saved registers preserved when switching from C to JavaScript.
static const RegList kCalleeSaved = const RegList kCalleeSaved =
1 << 16 | // s0 1 << 16 | // s0
1 << 17 | // s1 1 << 17 | // s1
1 << 18 | // s2 1 << 18 | // s2
...@@ -74,9 +74,9 @@ static const RegList kCalleeSaved = ...@@ -74,9 +74,9 @@ static const RegList kCalleeSaved =
1 << 23 | // s7 (cp in Javascript code) 1 << 23 | // s7 (cp in Javascript code)
1 << 30; // fp/s8 1 << 30; // fp/s8
static const int kNumCalleeSaved = 9; const int kNumCalleeSaved = 9;
static const RegList kCalleeSavedFPU = const RegList kCalleeSavedFPU =
1 << 20 | // f20 1 << 20 | // f20
1 << 22 | // f22 1 << 22 | // f22
1 << 24 | // f24 1 << 24 | // f24
...@@ -84,9 +84,9 @@ static const RegList kCalleeSavedFPU = ...@@ -84,9 +84,9 @@ static const RegList kCalleeSavedFPU =
1 << 28 | // f28 1 << 28 | // f28
1 << 30; // f30 1 << 30; // f30
static const int kNumCalleeSavedFPU = 6; const int kNumCalleeSavedFPU = 6;
static const RegList kCallerSavedFPU = const RegList kCallerSavedFPU =
1 << 0 | // f0 1 << 0 | // f0
1 << 2 | // f2 1 << 2 | // f2
1 << 4 | // f4 1 << 4 | // f4
...@@ -101,20 +101,20 @@ static const RegList kCallerSavedFPU = ...@@ -101,20 +101,20 @@ static const RegList kCallerSavedFPU =
// Number of registers for which space is reserved in safepoints. Must be a // Number of registers for which space is reserved in safepoints. Must be a
// multiple of 8. // multiple of 8.
static const int kNumSafepointRegisters = 24; const int kNumSafepointRegisters = 24;
// Define the list of registers actually saved at safepoints. // Define the list of registers actually saved at safepoints.
// Note that the number of saved registers may be smaller than the reserved // Note that the number of saved registers may be smaller than the reserved
// space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters. // space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters.
static const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved; const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved;
static const int kNumSafepointSavedRegisters = const int kNumSafepointSavedRegisters =
kNumJSCallerSaved + kNumCalleeSaved; kNumJSCallerSaved + kNumCalleeSaved;
typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved];
static const int kUndefIndex = -1; const int kUndefIndex = -1;
// Map with indexes on stack that corresponds to codes of saved registers. // Map with indexes on stack that corresponds to codes of saved registers.
static const int kSafepointRegisterStackIndexMap[kNumRegs] = { const int kSafepointRegisterStackIndexMap[kNumRegs] = {
kUndefIndex, // zero_reg kUndefIndex, // zero_reg
kUndefIndex, // at kUndefIndex, // at
0, // v0 0, // v0
......
src/mips/macro-assembler-mips.h
View file @ 0a701045
...@@ -102,25 +102,25 @@ bool AreAliased(Register r1, Register r2, Register r3, Register r4); ...@@ -102,25 +102,25 @@ bool AreAliased(Register r1, Register r2, Register r3, Register r4);
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// Static helper functions. // Static helper functions.
static MemOperand ContextOperand(Register context, int index) { inline MemOperand ContextOperand(Register context, int index) {
return MemOperand(context, Context::SlotOffset(index)); return MemOperand(context, Context::SlotOffset(index));
} }
static inline MemOperand GlobalObjectOperand() { inline MemOperand GlobalObjectOperand() {
return ContextOperand(cp, Context::GLOBAL_INDEX); return ContextOperand(cp, Context::GLOBAL_INDEX);
} }
// Generate a MemOperand for loading a field from an object. // Generate a MemOperand for loading a field from an object.
static inline MemOperand FieldMemOperand(Register object, int offset) { inline MemOperand FieldMemOperand(Register object, int offset) {
return MemOperand(object, offset - kHeapObjectTag); return MemOperand(object, offset - kHeapObjectTag);
} }
// Generate a MemOperand for storing arguments 5..N on the stack // Generate a MemOperand for storing arguments 5..N on the stack
// when calling CallCFunction(). // when calling CallCFunction().
static inline MemOperand CFunctionArgumentOperand(int index) { inline MemOperand CFunctionArgumentOperand(int index) {
ASSERT(index > kCArgSlotCount); ASSERT(index > kCArgSlotCount);
// Argument 5 takes the slot just past the four Arg-slots. // Argument 5 takes the slot just past the four Arg-slots.
int offset = (index - 5) * kPointerSize + kCArgsSlotsSize; int offset = (index - 5) * kPointerSize + kCArgsSlotsSize;
......
src/objects.h
View file @ 0a701045
...@@ -162,8 +162,7 @@ enum ElementsKind { ...@@ -162,8 +162,7 @@ enum ElementsKind {
LAST_ELEMENTS_KIND = EXTERNAL_PIXEL_ELEMENTS LAST_ELEMENTS_KIND = EXTERNAL_PIXEL_ELEMENTS
}; };
static const int kElementsKindCount = const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1;
LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1;
void PrintElementsKind(FILE* out, ElementsKind kind); void PrintElementsKind(FILE* out, ElementsKind kind);
...@@ -198,7 +197,7 @@ enum CreationFlag { ...@@ -198,7 +197,7 @@ enum CreationFlag {
// Instance size sentinel for objects of variable size. // Instance size sentinel for objects of variable size.
static const int kVariableSizeSentinel = 0; const int kVariableSizeSentinel = 0;
// All Maps have a field instance_type containing a InstanceType. // All Maps have a field instance_type containing a InstanceType.
...@@ -650,8 +649,8 @@ enum InstanceType { ...@@ -650,8 +649,8 @@ enum InstanceType {
NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2 NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2
}; };
static const int kExternalArrayTypeCount = LAST_EXTERNAL_ARRAY_TYPE - const int kExternalArrayTypeCount =
FIRST_EXTERNAL_ARRAY_TYPE + 1; LAST_EXTERNAL_ARRAY_TYPE - FIRST_EXTERNAL_ARRAY_TYPE + 1;
STATIC_CHECK(JS_OBJECT_TYPE == Internals::kJSObjectType); STATIC_CHECK(JS_OBJECT_TYPE == Internals::kJSObjectType);
STATIC_CHECK(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType); STATIC_CHECK(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType);
......
src/string-search.h
View file @ 0a701045
// Copyright 2010 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -242,9 +242,9 @@ int StringSearch<PatternChar, SubjectChar>::SingleCharSearch( ...@@ -242,9 +242,9 @@ int StringSearch<PatternChar, SubjectChar>::SingleCharSearch(
template <typename PatternChar, typename SubjectChar> template <typename PatternChar, typename SubjectChar>
static inline bool CharCompare(const PatternChar* pattern, inline bool CharCompare(const PatternChar* pattern,
const SubjectChar* subject, const SubjectChar* subject,
int length) { int length) {
ASSERT(length > 0); ASSERT(length > 0);
int pos = 0; int pos = 0;
do { do {
...@@ -555,10 +555,10 @@ int StringSearch<PatternChar, SubjectChar>::InitialSearch( ...@@ -555,10 +555,10 @@ int StringSearch<PatternChar, SubjectChar>::InitialSearch(
// object should be constructed once and the Search function then called // object should be constructed once and the Search function then called
// for each search. // for each search.
template <typename SubjectChar, typename PatternChar> template <typename SubjectChar, typename PatternChar>
static int SearchString(Isolate* isolate, int SearchString(Isolate* isolate,
Vector<const SubjectChar> subject, Vector<const SubjectChar> subject,
Vector<const PatternChar> pattern, Vector<const PatternChar> pattern,
int start_index) { int start_index) {
StringSearch<PatternChar, SubjectChar> search(isolate, pattern); StringSearch<PatternChar, SubjectChar> search(isolate, pattern);
return search.Search(subject, start_index); return search.Search(subject, start_index);
} }
......
src/unicode.h
View file @ 0a701045
// Copyright 2007-2008 the V8 project authors. All rights reserved. // Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are // modification, are permitted provided that the following conditions are
// met: // met:
...@@ -44,7 +44,7 @@ typedef unsigned char byte; ...@@ -44,7 +44,7 @@ typedef unsigned char byte;
* The max length of the result of converting the case of a single * The max length of the result of converting the case of a single
* character. * character.
*/ */
static const int kMaxMappingSize = 4; const int kMaxMappingSize = 4;
template <class T, int size = 256> template <class T, int size = 256>
class Predicate { class Predicate {
......
src/utils.h
View file @ 0a701045
...@@ -47,13 +47,13 @@ namespace internal { ...@@ -47,13 +47,13 @@ namespace internal {
// Returns true iff x is a power of 2 (or zero). Cannot be used with the // Returns true iff x is a power of 2 (or zero). Cannot be used with the
// maximally negative value of the type T (the -1 overflows). // maximally negative value of the type T (the -1 overflows).
template <typename T> template <typename T>
static inline bool IsPowerOf2(T x) { inline bool IsPowerOf2(T x) {
return IS_POWER_OF_TWO(x); return IS_POWER_OF_TWO(x);
} }
// X must be a power of 2. Returns the number of trailing zeros. // X must be a power of 2. Returns the number of trailing zeros.
static inline int WhichPowerOf2(uint32_t x) { inline int WhichPowerOf2(uint32_t x) {
ASSERT(IsPowerOf2(x)); ASSERT(IsPowerOf2(x));
ASSERT(x != 0); ASSERT(x != 0);
int bits = 0; int bits = 0;
...@@ -88,7 +88,7 @@ static inline int WhichPowerOf2(uint32_t x) { ...@@ -88,7 +88,7 @@ static inline int WhichPowerOf2(uint32_t x) {
// The C++ standard leaves the semantics of '>>' undefined for // The C++ standard leaves the semantics of '>>' undefined for
// negative signed operands. Most implementations do the right thing, // negative signed operands. Most implementations do the right thing,
// though. // though.
static inline int ArithmeticShiftRight(int x, int s) { inline int ArithmeticShiftRight(int x, int s) {
return x >> s; return x >> s;
} }
...@@ -97,7 +97,7 @@ static inline int ArithmeticShiftRight(int x, int s) { ...@@ -97,7 +97,7 @@ static inline int ArithmeticShiftRight(int x, int s) {
// This allows conversion of Addresses and integral types into // This allows conversion of Addresses and integral types into
// 0-relative int offsets. // 0-relative int offsets.
template <typename T> template <typename T>
static inline intptr_t OffsetFrom(T x) { inline intptr_t OffsetFrom(T x) {
return x - static_cast<T>(0); return x - static_cast<T>(0);
} }
...@@ -106,14 +106,14 @@ static inline intptr_t OffsetFrom(T x) { ...@@ -106,14 +106,14 @@ static inline intptr_t OffsetFrom(T x) {
// This allows conversion of 0-relative int offsets into Addresses and // This allows conversion of 0-relative int offsets into Addresses and
// integral types. // integral types.
template <typename T> template <typename T>
static inline T AddressFrom(intptr_t x) { inline T AddressFrom(intptr_t x) {
return static_cast<T>(static_cast<T>(0) + x); return static_cast<T>(static_cast<T>(0) + x);
} }
// Return the largest multiple of m which is <= x. // Return the largest multiple of m which is <= x.
template <typename T> template <typename T>
static inline T RoundDown(T x, intptr_t m) { inline T RoundDown(T x, intptr_t m) {
ASSERT(IsPowerOf2(m)); ASSERT(IsPowerOf2(m));
return AddressFrom<T>(OffsetFrom(x) & -m); return AddressFrom<T>(OffsetFrom(x) & -m);
} }
...@@ -121,13 +121,13 @@ static inline T RoundDown(T x, intptr_t m) { ...@@ -121,13 +121,13 @@ static inline T RoundDown(T x, intptr_t m) {
// Return the smallest multiple of m which is >= x. // Return the smallest multiple of m which is >= x.
template <typename T> template <typename T>
static inline T RoundUp(T x, intptr_t m) { inline T RoundUp(T x, intptr_t m) {
return RoundDown<T>(static_cast<T>(x + m - 1), m); return RoundDown<T>(static_cast<T>(x + m - 1), m);
} }
template <typename T> template <typename T>
static int Compare(const T& a, const T& b) { int Compare(const T& a, const T& b) {
if (a == b) if (a == b)
return 0; return 0;
else if (a < b) else if (a < b)
...@@ -138,7 +138,7 @@ static int Compare(const T& a, const T& b) { ...@@ -138,7 +138,7 @@ static int Compare(const T& a, const T& b) {
template <typename T> template <typename T>
static int PointerValueCompare(const T* a, const T* b) { int PointerValueCompare(const T* a, const T* b) {
return Compare<T>(*a, *b); return Compare<T>(*a, *b);
} }
...@@ -148,7 +148,7 @@ static int PointerValueCompare(const T* a, const T* b) { ...@@ -148,7 +148,7 @@ static int PointerValueCompare(const T* a, const T* b) {
// handles. // handles.
template<typename T> class Handle; // Forward declaration. template<typename T> class Handle; // Forward declaration.
template <typename T> template <typename T>
static int HandleObjectPointerCompare(const Handle<T>* a, const Handle<T>* b) { int HandleObjectPointerCompare(const Handle<T>* a, const Handle<T>* b) {
return Compare<T*>(*(*a), *(*b)); return Compare<T*>(*(*a), *(*b));
} }
...@@ -157,7 +157,7 @@ static int HandleObjectPointerCompare(const Handle<T>* a, const Handle<T>* b) { ...@@ -157,7 +157,7 @@ static int HandleObjectPointerCompare(const Handle<T>* a, const Handle<T>* b) {
// number that is already a power of two, it is returned as is. // number that is already a power of two, it is returned as is.
// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr., // Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
// figure 3-3, page 48, where the function is called clp2. // figure 3-3, page 48, where the function is called clp2.
static inline uint32_t RoundUpToPowerOf2(uint32_t x) { inline uint32_t RoundUpToPowerOf2(uint32_t x) {
ASSERT(x <= 0x80000000u); ASSERT(x <= 0x80000000u);
x = x - 1; x = x - 1;
x = x | (x >> 1); x = x | (x >> 1);
...@@ -169,7 +169,7 @@ static inline uint32_t RoundUpToPowerOf2(uint32_t x) { ...@@ -169,7 +169,7 @@ static inline uint32_t RoundUpToPowerOf2(uint32_t x) {
} }
static inline uint32_t RoundDownToPowerOf2(uint32_t x) { inline uint32_t RoundDownToPowerOf2(uint32_t x) {
uint32_t rounded_up = RoundUpToPowerOf2(x); uint32_t rounded_up = RoundUpToPowerOf2(x);
if (rounded_up > x) return rounded_up >> 1; if (rounded_up > x) return rounded_up >> 1;
return rounded_up; return rounded_up;
...@@ -177,15 +177,15 @@ static inline uint32_t RoundDownToPowerOf2(uint32_t x) { ...@@ -177,15 +177,15 @@ static inline uint32_t RoundDownToPowerOf2(uint32_t x) {
template <typename T, typename U> template <typename T, typename U>
static inline bool IsAligned(T value, U alignment) { inline bool IsAligned(T value, U alignment) {
return (value & (alignment - 1)) == 0; return (value & (alignment - 1)) == 0;
} }
// Returns true if (addr + offset) is aligned. // Returns true if (addr + offset) is aligned.
static inline bool IsAddressAligned(Address addr, inline bool IsAddressAligned(Address addr,
intptr_t alignment, intptr_t alignment,
int offset = 0) { int offset = 0) {
intptr_t offs = OffsetFrom(addr + offset); intptr_t offs = OffsetFrom(addr + offset);
return IsAligned(offs, alignment); return IsAligned(offs, alignment);
} }
...@@ -193,14 +193,14 @@ static inline bool IsAddressAligned(Address addr, ...@@ -193,14 +193,14 @@ static inline bool IsAddressAligned(Address addr,
// Returns the maximum of the two parameters. // Returns the maximum of the two parameters.
template <typename T> template <typename T>
static T Max(T a, T b) { T Max(T a, T b) {
return a < b ? b : a; return a < b ? b : a;
} }
// Returns the minimum of the two parameters. // Returns the minimum of the two parameters.
template <typename T> template <typename T>
static T Min(T a, T b) { T Min(T a, T b) {
return a < b ? a : b; return a < b ? a : b;
} }
...@@ -254,7 +254,7 @@ class BitField { ...@@ -254,7 +254,7 @@ class BitField {
// Thomas Wang, Integer Hash Functions. // Thomas Wang, Integer Hash Functions.
// http://www.concentric.net/~Ttwang/tech/inthash.htm // http://www.concentric.net/~Ttwang/tech/inthash.htm
static inline uint32_t ComputeIntegerHash(uint32_t key) { inline uint32_t ComputeIntegerHash(uint32_t key) {
uint32_t hash = key; uint32_t hash = key;
hash = ~hash + (hash << 15); // hash = (hash << 15) - hash - 1; hash = ~hash + (hash << 15); // hash = (hash << 15) - hash - 1;
hash = hash ^ (hash >> 12); hash = hash ^ (hash >> 12);
...@@ -266,7 +266,7 @@ static inline uint32_t ComputeIntegerHash(uint32_t key) { ...@@ -266,7 +266,7 @@ static inline uint32_t ComputeIntegerHash(uint32_t key) {
} }
static inline uint32_t ComputeLongHash(uint64_t key) { inline uint32_t ComputeLongHash(uint64_t key) {
uint64_t hash = key; uint64_t hash = key;
hash = ~hash + (hash << 18); // hash = (hash << 18) - hash - 1; hash = ~hash + (hash << 18); // hash = (hash << 18) - hash - 1;
hash = hash ^ (hash >> 31); hash = hash ^ (hash >> 31);
...@@ -278,7 +278,7 @@ static inline uint32_t ComputeLongHash(uint64_t key) { ...@@ -278,7 +278,7 @@ static inline uint32_t ComputeLongHash(uint64_t key) {
} }
static inline uint32_t ComputePointerHash(void* ptr) { inline uint32_t ComputePointerHash(void* ptr) {
return ComputeIntegerHash( return ComputeIntegerHash(
static_cast<uint32_t>(reinterpret_cast<intptr_t>(ptr))); static_cast<uint32_t>(reinterpret_cast<intptr_t>(ptr)));
} }
...@@ -734,7 +734,7 @@ class SequenceCollector : public Collector<T, growth_factor, max_growth> { ...@@ -734,7 +734,7 @@ class SequenceCollector : public Collector<T, growth_factor, max_growth> {
// Compare ASCII/16bit chars to ASCII/16bit chars. // Compare ASCII/16bit chars to ASCII/16bit chars.
template <typename lchar, typename rchar> template <typename lchar, typename rchar>
static inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) { inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) {
const lchar* limit = lhs + chars; const lchar* limit = lhs + chars;
#ifdef V8_HOST_CAN_READ_UNALIGNED #ifdef V8_HOST_CAN_READ_UNALIGNED
if (sizeof(*lhs) == sizeof(*rhs)) { if (sizeof(*lhs) == sizeof(*rhs)) {
...@@ -761,7 +761,7 @@ static inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) { ...@@ -761,7 +761,7 @@ static inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) {
// Calculate 10^exponent. // Calculate 10^exponent.
static inline int TenToThe(int exponent) { inline int TenToThe(int exponent) {
ASSERT(exponent <= 9); ASSERT(exponent <= 9);
ASSERT(exponent >= 1); ASSERT(exponent >= 1);
int answer = 10; int answer = 10;
......
src/v8conversions.h
View file @ 0a701045
...@@ -34,13 +34,13 @@ namespace v8 { ...@@ -34,13 +34,13 @@ namespace v8 {
namespace internal { namespace internal {
// Convert from Number object to C integer. // Convert from Number object to C integer.
static inline int32_t NumberToInt32(Object* number) { inline int32_t NumberToInt32(Object* number) {
if (number->IsSmi()) return Smi::cast(number)->value(); if (number->IsSmi()) return Smi::cast(number)->value();
return DoubleToInt32(number->Number()); return DoubleToInt32(number->Number());
} }
static inline uint32_t NumberToUint32(Object* number) { inline uint32_t NumberToUint32(Object* number) {
if (number->IsSmi()) return Smi::cast(number)->value(); if (number->IsSmi()) return Smi::cast(number)->value();
return DoubleToUint32(number->Number()); return DoubleToUint32(number->Number());
} }
......
src/v8globals.h
View file @ 0a701045
...@@ -484,9 +484,9 @@ enum ScopeType { ...@@ -484,9 +484,9 @@ enum ScopeType {
}; };
static const uint32_t kHoleNanUpper32 = 0x7FFFFFFF; const uint32_t kHoleNanUpper32 = 0x7FFFFFFF;
static const uint32_t kHoleNanLower32 = 0xFFFFFFFF; const uint32_t kHoleNanLower32 = 0xFFFFFFFF;
static const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000; const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000;
const uint64_t kHoleNanInt64 = const uint64_t kHoleNanInt64 =
(static_cast<uint64_t>(kHoleNanUpper32) << 32) | kHoleNanLower32; (static_cast<uint64_t>(kHoleNanUpper32) << 32) | kHoleNanLower32;
......
src/v8utils.h
View file @ 0a701045
...@@ -143,7 +143,7 @@ inline void CopyWords(T* dst, T* src, int num_words) { ...@@ -143,7 +143,7 @@ inline void CopyWords(T* dst, T* src, int num_words) {
template <typename T, typename U> template <typename T, typename U>
static inline void MemsetPointer(T** dest, U* value, int counter) { inline void MemsetPointer(T** dest, U* value, int counter) {
#ifdef DEBUG #ifdef DEBUG
T* a = NULL; T* a = NULL;
U* b = NULL; U* b = NULL;
...@@ -202,7 +202,7 @@ Vector<const char> ReadFile(FILE* file, ...@@ -202,7 +202,7 @@ Vector<const char> ReadFile(FILE* file,
// Copy from ASCII/16bit chars to ASCII/16bit chars. // Copy from ASCII/16bit chars to ASCII/16bit chars.
template <typename sourcechar, typename sinkchar> template <typename sourcechar, typename sinkchar>
static inline void CopyChars(sinkchar* dest, const sourcechar* src, int chars) { inline void CopyChars(sinkchar* dest, const sourcechar* src, int chars) {
sinkchar* limit = dest + chars; sinkchar* limit = dest + chars;
#ifdef V8_HOST_CAN_READ_UNALIGNED #ifdef V8_HOST_CAN_READ_UNALIGNED
if (sizeof(*dest) == sizeof(*src)) { if (sizeof(*dest) == sizeof(*src)) {
......
src/x64/assembler-x64.h
View file @ 0a701045
...@@ -45,22 +45,22 @@ namespace internal { ...@@ -45,22 +45,22 @@ namespace internal {
// Utility functions // Utility functions
// Test whether a 64-bit value is in a specific range. // Test whether a 64-bit value is in a specific range.
static inline bool is_uint32(int64_t x) { inline bool is_uint32(int64_t x) {
static const uint64_t kMaxUInt32 = V8_UINT64_C(0xffffffff); static const uint64_t kMaxUInt32 = V8_UINT64_C(0xffffffff);
return static_cast<uint64_t>(x) <= kMaxUInt32; return static_cast<uint64_t>(x) <= kMaxUInt32;
} }
static inline bool is_int32(int64_t x) { inline bool is_int32(int64_t x) {
static const int64_t kMinInt32 = -V8_INT64_C(0x80000000); static const int64_t kMinInt32 = -V8_INT64_C(0x80000000);
return is_uint32(x - kMinInt32); return is_uint32(x - kMinInt32);
} }
static inline bool uint_is_int32(uint64_t x) { inline bool uint_is_int32(uint64_t x) {
static const uint64_t kMaxInt32 = V8_UINT64_C(0x7fffffff); static const uint64_t kMaxInt32 = V8_UINT64_C(0x7fffffff);
return x <= kMaxInt32; return x <= kMaxInt32;
} }
static inline bool is_uint32(uint64_t x) { inline bool is_uint32(uint64_t x) {
static const uint64_t kMaxUInt32 = V8_UINT64_C(0xffffffff); static const uint64_t kMaxUInt32 = V8_UINT64_C(0xffffffff);
return x <= kMaxUInt32; return x <= kMaxUInt32;
} }
......
src/x64/frames-x64.h
View file @ 0a701045
...@@ -31,20 +31,20 @@ ...@@ -31,20 +31,20 @@
namespace v8 { namespace v8 {
namespace internal { namespace internal {
static const int kNumRegs = 16; const int kNumRegs = 16;
static const RegList kJSCallerSaved = const RegList kJSCallerSaved =
1 << 0 | // rax 1 << 0 | // rax
1 << 1 | // rcx 1 << 1 | // rcx
1 << 2 | // rdx 1 << 2 | // rdx
1 << 3 | // rbx - used as a caller-saved register in JavaScript code 1 << 3 | // rbx - used as a caller-saved register in JavaScript code
1 << 7; // rdi - callee function 1 << 7; // rdi - callee function
static const int kNumJSCallerSaved = 5; const int kNumJSCallerSaved = 5;
typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved];
// Number of registers for which space is reserved in safepoints. // Number of registers for which space is reserved in safepoints.
static const int kNumSafepointRegisters = 16; const int kNumSafepointRegisters = 16;
// ---------------------------------------------------- // ----------------------------------------------------
......
src/x64/macro-assembler-x64.h
View file @ 0a701045
...@@ -50,14 +50,14 @@ enum AllocationFlags { ...@@ -50,14 +50,14 @@ enum AllocationFlags {
// Default scratch register used by MacroAssembler (and other code that needs // Default scratch register used by MacroAssembler (and other code that needs
// a spare register). The register isn't callee save, and not used by the // a spare register). The register isn't callee save, and not used by the
// function calling convention. // function calling convention.
static const Register kScratchRegister = { 10 }; // r10. const Register kScratchRegister = { 10 }; // r10.
static const Register kSmiConstantRegister = { 12 }; // r12 (callee save). const Register kSmiConstantRegister = { 12 }; // r12 (callee save).
static const Register kRootRegister = { 13 }; // r13 (callee save). const Register kRootRegister = { 13 }; // r13 (callee save).
// Value of smi in kSmiConstantRegister. // Value of smi in kSmiConstantRegister.
static const int kSmiConstantRegisterValue = 1; const int kSmiConstantRegisterValue = 1;
// Actual value of root register is offset from the root array's start // Actual value of root register is offset from the root array's start
// to take advantage of negitive 8-bit displacement values. // to take advantage of negitive 8-bit displacement values.
static const int kRootRegisterBias = 128; const int kRootRegisterBias = 128;
// Convenience for platform-independent signatures. // Convenience for platform-independent signatures.
typedef Operand MemOperand; typedef Operand MemOperand;
...@@ -1367,32 +1367,32 @@ class CodePatcher { ...@@ -1367,32 +1367,32 @@ class CodePatcher {
// Static helper functions. // Static helper functions.
// Generate an Operand for loading a field from an object. // Generate an Operand for loading a field from an object.
static inline Operand FieldOperand(Register object, int offset) { inline Operand FieldOperand(Register object, int offset) {
return Operand(object, offset - kHeapObjectTag); return Operand(object, offset - kHeapObjectTag);
} }
// Generate an Operand for loading an indexed field from an object. // Generate an Operand for loading an indexed field from an object.
static inline Operand FieldOperand(Register object, inline Operand FieldOperand(Register object,
Register index, Register index,
ScaleFactor scale, ScaleFactor scale,
int offset) { int offset) {
return Operand(object, index, scale, offset - kHeapObjectTag); return Operand(object, index, scale, offset - kHeapObjectTag);
} }
static inline Operand ContextOperand(Register context, int index) { inline Operand ContextOperand(Register context, int index) {
return Operand(context, Context::SlotOffset(index)); return Operand(context, Context::SlotOffset(index));
} }
static inline Operand GlobalObjectOperand() { inline Operand GlobalObjectOperand() {
return ContextOperand(rsi, Context::GLOBAL_INDEX); return ContextOperand(rsi, Context::GLOBAL_INDEX);
} }
// Provides access to exit frame stack space (not GCed). // Provides access to exit frame stack space (not GCed).
static inline Operand StackSpaceOperand(int index) { inline Operand StackSpaceOperand(int index) {
#ifdef _WIN64 #ifdef _WIN64
const int kShaddowSpace = 4; const int kShaddowSpace = 4;
return Operand(rsp, (index + kShaddowSpace) * kPointerSize); return Operand(rsp, (index + kShaddowSpace) * kPointerSize);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment