diff --git a/include/v8.h b/include/v8.h index 9c8b9c7afc..7cad7b6280 100644 --- a/include/v8.h +++ b/include/v8.h @@ -3704,8 +3704,8 @@ class V8EXPORT ActivityControl { // NOLINT namespace internal { -static const int kApiPointerSize = sizeof(void*); // NOLINT -static const int kApiIntSize = sizeof(int); // NOLINT +const int kApiPointerSize = sizeof(void*); // NOLINT +const int kApiIntSize = sizeof(int); // NOLINT // Tag information for HeapObject. const int kHeapObjectTag = 1; diff --git a/src/allocation.h b/src/allocation.h index 75aba35d8c..00c5664ea9 100644 --- a/src/allocation.h +++ b/src/allocation.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -81,7 +81,7 @@ class AllStatic { template -static T* NewArray(int size) { +T* NewArray(int size) { T* result = new T[size]; if (result == NULL) Malloced::FatalProcessOutOfMemory(); return result; @@ -89,7 +89,7 @@ static T* NewArray(int size) { template -static void DeleteArray(T* array) { +void DeleteArray(T* array) { delete[] array; } diff --git a/src/api.h b/src/api.h index 7e7f6354c0..a825dd7970 100644 --- a/src/api.h +++ b/src/api.h @@ -112,7 +112,7 @@ void NeanderObject::set(int offset, v8::internal::Object* value) { } -template static inline T ToCData(v8::internal::Object* obj) { +template inline T ToCData(v8::internal::Object* obj) { STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address)); return reinterpret_cast( reinterpret_cast( @@ -121,7 +121,7 @@ template static inline T ToCData(v8::internal::Object* obj) { template -static inline v8::internal::Handle FromCData(T obj) { +inline v8::internal::Handle FromCData(T obj) { STATIC_ASSERT(sizeof(T) == sizeof(v8::internal::Address)); return FACTORY->NewForeign( reinterpret_cast(reinterpret_cast(obj))); @@ -236,7 +236,7 @@ class Utils { template -static inline T* ToApi(v8::internal::Handle obj) { +inline T* ToApi(v8::internal::Handle obj) { return reinterpret_cast(obj.location()); } @@ -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) { diff --git a/src/arm/constants-arm.h b/src/arm/constants-arm.h index 823c6ff7e1..49b8db79f8 100644 --- a/src/arm/constants-arm.h +++ b/src/arm/constants-arm.h @@ -87,22 +87,21 @@ namespace v8 { namespace internal { // Constant pool marker. -static const int kConstantPoolMarkerMask = 0xffe00000; -static const int kConstantPoolMarker = 0x0c000000; -static const int kConstantPoolLengthMask = 0x001ffff; +const int kConstantPoolMarkerMask = 0xffe00000; +const int kConstantPoolMarker = 0x0c000000; +const int kConstantPoolLengthMask = 0x001ffff; // Number of registers in normal ARM mode. -static const int kNumRegisters = 16; +const int kNumRegisters = 16; // VFP support. -static const int kNumVFPSingleRegisters = 32; -static const int kNumVFPDoubleRegisters = 16; -static const int kNumVFPRegisters = - kNumVFPSingleRegisters + kNumVFPDoubleRegisters; +const int kNumVFPSingleRegisters = 32; +const int kNumVFPDoubleRegisters = 16; +const int kNumVFPRegisters = kNumVFPSingleRegisters + kNumVFPDoubleRegisters; // PC is register 15. -static const int kPCRegister = 15; -static const int kNoRegister = -1; +const int kPCRegister = 15; +const int kNoRegister = -1; // ----------------------------------------------------------------------------- // Conditions. @@ -371,9 +370,9 @@ enum SoftwareInterruptCodes { // stop kStopCode = 1 << 23 }; -static const uint32_t kStopCodeMask = kStopCode - 1; -static const uint32_t kMaxStopCode = kStopCode - 1; -static const int32_t kDefaultStopCode = -1; +const uint32_t kStopCodeMask = kStopCode - 1; +const uint32_t kMaxStopCode = kStopCode - 1; +const int32_t kDefaultStopCode = -1; // Type of VFP register. Determines register encoding. @@ -391,17 +390,17 @@ enum VFPConversionMode { // This mask does not include the "inexact" or "input denormal" cumulative // exceptions flags, because we usually don't want to check for it. -static const uint32_t kVFPExceptionMask = 0xf; -static const uint32_t kVFPInvalidOpExceptionBit = 1 << 0; -static const uint32_t kVFPOverflowExceptionBit = 1 << 2; -static const uint32_t kVFPUnderflowExceptionBit = 1 << 3; -static const uint32_t kVFPInexactExceptionBit = 1 << 4; -static const uint32_t kVFPFlushToZeroMask = 1 << 24; +const uint32_t kVFPExceptionMask = 0xf; +const uint32_t kVFPInvalidOpExceptionBit = 1 << 0; +const uint32_t kVFPOverflowExceptionBit = 1 << 2; +const uint32_t kVFPUnderflowExceptionBit = 1 << 3; +const uint32_t kVFPInexactExceptionBit = 1 << 4; +const uint32_t kVFPFlushToZeroMask = 1 << 24; -static const uint32_t kVFPNConditionFlagBit = 1 << 31; -static const uint32_t kVFPZConditionFlagBit = 1 << 30; -static const uint32_t kVFPCConditionFlagBit = 1 << 29; -static const uint32_t kVFPVConditionFlagBit = 1 << 28; +const uint32_t kVFPNConditionFlagBit = 1 << 31; +const uint32_t kVFPZConditionFlagBit = 1 << 30; +const uint32_t kVFPCConditionFlagBit = 1 << 29; +const uint32_t kVFPVConditionFlagBit = 1 << 28; // VFP rounding modes. See ARM DDI 0406B Page A2-29. @@ -418,7 +417,7 @@ enum VFPRoundingMode { kRoundToZero = RZ }; -static const uint32_t kVFPRoundingModeMask = 3 << 22; +const uint32_t kVFPRoundingModeMask = 3 << 22; enum CheckForInexactConversion { kCheckForInexactConversion, diff --git a/src/arm/frames-arm.h b/src/arm/frames-arm.h index d0ea4fc4cc..1844149861 100644 --- a/src/arm/frames-arm.h +++ b/src/arm/frames-arm.h @@ -35,22 +35,22 @@ namespace internal { // 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 // 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 // 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 -static const RegList kJSCallerSaved = +const RegList kJSCallerSaved = 1 << 0 | // r0 a1 1 << 1 | // r1 a2 1 << 2 | // r2 a3 1 << 3; // r3 a4 -static const int kNumJSCallerSaved = 4; +const int kNumJSCallerSaved = 4; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; @@ -60,7 +60,7 @@ int JSCallerSavedCode(int n); // Callee-saved registers preserved when switching from C to JavaScript -static const RegList kCalleeSaved = +const RegList kCalleeSaved = 1 << 4 | // r4 v1 1 << 5 | // r5 v2 1 << 6 | // r6 v3 @@ -72,7 +72,7 @@ static const RegList kCalleeSaved = // When calling into C++ (only for C++ calls that can't cause a GC). // The call code will take care of lr, fp, etc. -static const RegList kCallerSaved = +const RegList kCallerSaved = 1 << 0 | // r0 1 << 1 | // r1 1 << 2 | // r2 @@ -80,23 +80,22 @@ static const RegList kCallerSaved = 1 << 9; // r9 -static const int kNumCalleeSaved = 7 + kR9Available; +const int kNumCalleeSaved = 7 + kR9Available; // 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 // multiple of 8. // 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. // Note that the number of saved registers may be smaller than the reserved // space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters. -static const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved; -static const int kNumSafepointSavedRegisters = - kNumJSCallerSaved + kNumCalleeSaved; +const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved; +const int kNumSafepointSavedRegisters = kNumJSCallerSaved + kNumCalleeSaved; // ---------------------------------------------------- diff --git a/src/arm/macro-assembler-arm.h b/src/arm/macro-assembler-arm.h index 56b4bbb89d..2725883ee1 100644 --- a/src/arm/macro-assembler-arm.h +++ b/src/arm/macro-assembler-arm.h @@ -39,12 +39,12 @@ namespace internal { // Static helper functions // 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); } -static inline Operand SmiUntagOperand(Register object) { +inline Operand SmiUntagOperand(Register object) { return Operand(object, ASR, kSmiTagSize); } @@ -1300,12 +1300,12 @@ class CodePatcher { // ----------------------------------------------------------------------------- // Static helper functions. -static MemOperand ContextOperand(Register context, int index) { +inline MemOperand ContextOperand(Register context, int index) { return MemOperand(context, Context::SlotOffset(index)); } -static inline MemOperand GlobalObjectOperand() { +inline MemOperand GlobalObjectOperand() { return ContextOperand(cp, Context::GLOBAL_INDEX); } diff --git a/src/assembler.h b/src/assembler.h index c4bb212574..5c25768e6a 100644 --- a/src/assembler.h +++ b/src/assembler.h @@ -817,33 +817,33 @@ class PreservePositionScope BASE_EMBEDDED { // ----------------------------------------------------------------------------- // 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)); } -static inline bool is_int8(int x) { return is_intn(x, 8); } -static inline bool is_int16(int x) { return is_intn(x, 16); } -static 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_int8(int x) { return is_intn(x, 8); } +inline bool is_int16(int x) { return is_intn(x, 16); } +inline bool is_int18(int x) { return is_intn(x, 18); } +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; } -static inline bool is_uint2(int x) { return is_uintn(x, 2); } -static inline bool is_uint3(int x) { return is_uintn(x, 3); } -static inline bool is_uint4(int x) { return is_uintn(x, 4); } -static inline bool is_uint5(int x) { return is_uintn(x, 5); } -static inline bool is_uint6(int x) { return is_uintn(x, 6); } -static inline bool is_uint8(int x) { return is_uintn(x, 8); } -static inline bool is_uint10(int x) { return is_uintn(x, 10); } -static inline bool is_uint12(int x) { return is_uintn(x, 12); } -static inline bool is_uint16(int x) { return is_uintn(x, 16); } -static inline bool is_uint24(int x) { return is_uintn(x, 24); } -static 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_uint2(int x) { return is_uintn(x, 2); } +inline bool is_uint3(int x) { return is_uintn(x, 3); } +inline bool is_uint4(int x) { return is_uintn(x, 4); } +inline bool is_uint5(int x) { return is_uintn(x, 5); } +inline bool is_uint6(int x) { return is_uintn(x, 6); } +inline bool is_uint8(int x) { return is_uintn(x, 8); } +inline bool is_uint10(int x) { return is_uintn(x, 10); } +inline bool is_uint12(int x) { return is_uintn(x, 12); } +inline bool is_uint16(int x) { return is_uintn(x, 16); } +inline bool is_uint24(int x) { return is_uintn(x, 24); } +inline bool is_uint26(int x) { return is_uintn(x, 26); } +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; for (num_bits_set = 0; x; x >>= 1) { num_bits_set += x & 1; diff --git a/src/bytecodes-irregexp.h b/src/bytecodes-irregexp.h index 93218ea9f1..b13efb36f8 100644 --- a/src/bytecodes-irregexp.h +++ b/src/bytecodes-irregexp.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -33,12 +33,12 @@ namespace v8 { 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 // has 24 bits, but it can be positive and negative so only use 23 bits for // positive values. -static const unsigned int MAX_FIRST_ARG = 0x7fffffu; -static const int BYTECODE_SHIFT = 8; +const unsigned int MAX_FIRST_ARG = 0x7fffffu; +const int BYTECODE_SHIFT = 8; #define BYTECODE_ITERATOR(V) \ V(BREAK, 0, 4) /* bc8 */ \ diff --git a/src/char-predicates-inl.h b/src/char-predicates-inl.h index 0dfc80d0b8..1a89ef3b11 100644 --- a/src/char-predicates-inl.h +++ b/src/char-predicates-inl.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -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); return static_cast(value - lower_limit) <= static_cast(higher_limit - lower_limit); diff --git a/src/checks.h b/src/checks.h index 832f778b25..8608b0eba9 100644 --- a/src/checks.h +++ b/src/checks.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -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. -static inline void CheckHelper(const char* file, - int line, - const char* source, - bool condition) { +inline void CheckHelper(const char* file, + int line, + const char* source, + bool condition) { if (!condition) V8_Fatal(file, line, "CHECK(%s) failed", source); } @@ -70,9 +70,9 @@ static inline void CheckHelper(const char* file, // Helper function used by the CHECK_EQ function when given int // arguments. Should not be called directly. -static inline void CheckEqualsHelper(const char* file, int line, - const char* expected_source, int expected, - const char* value_source, int value) { +inline void CheckEqualsHelper(const char* file, int line, + const char* expected_source, int expected, + const char* value_source, int value) { if (expected != value) { V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n# Expected: %i\n# Found: %i", @@ -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 // arguments. Should not be called directly. -static inline void CheckEqualsHelper(const char* file, int line, - const char* expected_source, - int64_t expected, - const char* value_source, - int64_t value) { +inline void CheckEqualsHelper(const char* file, int line, + const char* expected_source, + int64_t expected, + const char* value_source, + int64_t value) { if (expected != value) { // Print int64_t values in hex, as two int32s, // to avoid platform-dependencies. @@ -105,12 +105,12 @@ static inline void CheckEqualsHelper(const char* file, int line, // Helper function used by the CHECK_NE function when given int // arguments. Should not be called directly. -static inline void CheckNonEqualsHelper(const char* file, - int line, - const char* unexpected_source, - int unexpected, - const char* value_source, - int value) { +inline void CheckNonEqualsHelper(const char* file, + int line, + const char* unexpected_source, + int unexpected, + const char* value_source, + int value) { if (unexpected == value) { V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %i", unexpected_source, value_source, value); @@ -120,12 +120,12 @@ static inline void CheckNonEqualsHelper(const char* file, // Helper function used by the CHECK function when given string // arguments. Should not be called directly. -static inline void CheckEqualsHelper(const char* file, - int line, - const char* expected_source, - const char* expected, - const char* value_source, - const char* value) { +inline void CheckEqualsHelper(const char* file, + int line, + const char* expected_source, + const char* expected, + const char* value_source, + const char* value) { if ((expected == NULL && value != NULL) || (expected != NULL && value == NULL) || (expected != NULL && value != NULL && strcmp(expected, value) != 0)) { @@ -136,12 +136,12 @@ static inline void CheckEqualsHelper(const char* file, } -static inline void CheckNonEqualsHelper(const char* file, - int line, - const char* expected_source, - const char* expected, - const char* value_source, - const char* value) { +inline void CheckNonEqualsHelper(const char* file, + int line, + const char* expected_source, + const char* expected, + const char* value_source, + const char* value) { if (expected == value || (expected != NULL && value != NULL && strcmp(expected, value) == 0)) { V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %s", @@ -152,12 +152,12 @@ static inline void CheckNonEqualsHelper(const char* file, // Helper function used by the CHECK function when given pointer // arguments. Should not be called directly. -static inline void CheckEqualsHelper(const char* file, - int line, - const char* expected_source, - const void* expected, - const char* value_source, - const void* value) { +inline void CheckEqualsHelper(const char* file, + int line, + const char* expected_source, + const void* expected, + const char* value_source, + const void* value) { if (expected != value) { V8_Fatal(file, line, "CHECK_EQ(%s, %s) failed\n# Expected: %p\n# Found: %p", @@ -167,12 +167,12 @@ static inline void CheckEqualsHelper(const char* file, } -static inline void CheckNonEqualsHelper(const char* file, - int line, - const char* expected_source, - const void* expected, - const char* value_source, - const void* value) { +inline void CheckNonEqualsHelper(const char* file, + int line, + const char* expected_source, + const void* expected, + const char* value_source, + const void* value) { if (expected == value) { V8_Fatal(file, line, "CHECK_NE(%s, %s) failed\n# Value: %p", expected_source, value_source, value); @@ -182,12 +182,12 @@ static inline void CheckNonEqualsHelper(const char* file, // Helper function used by the CHECK function when given floating // point arguments. Should not be called directly. -static inline void CheckEqualsHelper(const char* file, - int line, - const char* expected_source, - double expected, - const char* value_source, - double value) { +inline void CheckEqualsHelper(const char* file, + int line, + const char* expected_source, + double expected, + const char* value_source, + double value) { // Force values to 64 bit memory to truncate 80 bit precision on IA32. volatile double* exp = new double[1]; *exp = expected; @@ -203,12 +203,12 @@ static inline void CheckEqualsHelper(const char* file, } -static inline void CheckNonEqualsHelper(const char* file, - int line, - const char* expected_source, - double expected, - const char* value_source, - double value) { +inline void CheckNonEqualsHelper(const char* file, + int line, + const char* expected_source, + double expected, + const char* value_source, + double value) { // Force values to 64 bit memory to truncate 80 bit precision on IA32. volatile double* exp = new double[1]; *exp = expected; diff --git a/src/conversions-inl.h b/src/conversions-inl.h index 8bc11bf83d..b098a1c29c 100644 --- a/src/conversions-inl.h +++ b/src/conversions-inl.h @@ -46,7 +46,7 @@ namespace v8 { namespace internal { -static inline double JunkStringValue() { +inline double JunkStringValue() { return BitCast(kQuietNaNMask); } @@ -54,7 +54,7 @@ static inline double JunkStringValue() { // The fast double-to-unsigned-int conversion routine does not guarantee // rounding towards zero, or any reasonable value if the argument is larger // 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 // in this function as there is in FastD2I. Using lrint doesn't work // for values of 2^31 and above. @@ -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 (!isfinite(x) || x == 0) return x; return (x >= 0) ? floor(x) : ceil(x); @@ -103,9 +103,9 @@ int32_t DoubleToInt32(double x) { template -static bool SubStringEquals(Iterator* current, - EndMark end, - const char* substring) { +bool SubStringEquals(Iterator* current, + EndMark end, + const char* substring) { ASSERT(**current == *substring); for (substring++; *substring != '\0'; substring++) { ++*current; @@ -119,9 +119,9 @@ static bool SubStringEquals(Iterator* current, // Returns true if a nonspace character has been found and false if the // end was been reached before finding a nonspace character. template -static inline bool AdvanceToNonspace(UnicodeCache* unicode_cache, - Iterator* current, - EndMark end) { +inline bool AdvanceToNonspace(UnicodeCache* unicode_cache, + Iterator* current, + EndMark end) { while (*current != end) { if (!unicode_cache->IsWhiteSpace(**current)) return true; ++*current; @@ -132,11 +132,11 @@ static inline bool AdvanceToNonspace(UnicodeCache* unicode_cache, // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end. template -static double InternalStringToIntDouble(UnicodeCache* unicode_cache, - Iterator current, - EndMark end, - bool negative, - bool allow_trailing_junk) { +double InternalStringToIntDouble(UnicodeCache* unicode_cache, + Iterator current, + EndMark end, + bool negative, + bool allow_trailing_junk) { ASSERT(current != end); // Skip leading 0s. @@ -235,10 +235,10 @@ static double InternalStringToIntDouble(UnicodeCache* unicode_cache, template -static double InternalStringToInt(UnicodeCache* unicode_cache, - Iterator current, - EndMark end, - int radix) { +double InternalStringToInt(UnicodeCache* unicode_cache, + Iterator current, + EndMark end, + int radix) { const bool allow_trailing_junk = true; const double empty_string_val = JunkStringValue(); @@ -430,11 +430,11 @@ static double InternalStringToInt(UnicodeCache* unicode_cache, // 2. *current - gets the current character in the sequence. // 3. ++current (advances the position). template -static double InternalStringToDouble(UnicodeCache* unicode_cache, - Iterator current, - EndMark end, - int flags, - double empty_string_val) { +double InternalStringToDouble(UnicodeCache* unicode_cache, + Iterator current, + EndMark end, + int flags, + double empty_string_val) { // To make sure that iterator dereferencing is valid the following // convention is used: // 1. Each '++current' statement is followed by check for equality to 'end'. diff --git a/src/conversions.h b/src/conversions.h index 31aaf6b737..70559c9e9d 100644 --- a/src/conversions.h +++ b/src/conversions.h @@ -45,14 +45,14 @@ class UnicodeCache; 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) || (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; } @@ -61,16 +61,16 @@ static inline double SignedZero(bool negative) { // rounding towards zero. // The result is unspecified if x is infinite or NaN, or if the rounded // 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 // as new benchmarks show, now it is much faster than lrint(). return static_cast(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 // double, so this code should compile to a few instructions without // any FPU pipeline stalls. @@ -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 // double, so this code should compile to a few instructions without // any FPU pipeline stalls. @@ -87,15 +87,15 @@ static inline double FastUI2D(unsigned x) { // 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. -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. -static inline uint32_t DoubleToUint32(double x) { +inline uint32_t DoubleToUint32(double x) { return static_cast(DoubleToInt32(x)); } diff --git a/src/double.h b/src/double.h index 65eded9989..16a3245e9a 100644 --- a/src/double.h +++ b/src/double.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -34,8 +34,8 @@ namespace v8 { namespace internal { // We assume that doubles and uint64_t have the same endianness. -static uint64_t double_to_uint64(double d) { return BitCast(d); } -static double uint64_to_double(uint64_t d64) { return BitCast(d64); } +inline uint64_t double_to_uint64(double d) { return BitCast(d); } +inline double uint64_to_double(uint64_t d64) { return BitCast(d64); } // Helper functions for doubles. class Double { diff --git a/src/dtoa.h b/src/dtoa.h index b3e79afa48..a2d6fdebde 100644 --- a/src/dtoa.h +++ b/src/dtoa.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -47,7 +47,7 @@ enum DtoaMode { // The maximal length of digits a double can have in base 10. // Note that DoubleToAscii null-terminates its input. So the given buffer should // be at least kBase10MaximalLength + 1 characters long. -static const int kBase10MaximalLength = 17; +const int kBase10MaximalLength = 17; // Converts the given double 'v' to ascii. // The result should be interpreted as buffer * 10^(point-length). diff --git a/src/fast-dtoa.h b/src/fast-dtoa.h index 94c22ecd7c..ef28557934 100644 --- a/src/fast-dtoa.h +++ b/src/fast-dtoa.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -43,7 +43,7 @@ enum FastDtoaMode { // FastDtoa will produce at most kFastDtoaMaximalLength digits. This does not // include the terminating '\0' character. -static const int kFastDtoaMaximalLength = 17; +const int kFastDtoaMaximalLength = 17; // Provides a decimal representation of v. // The result should be interpreted as buffer * 10^(point - length). diff --git a/src/globals.h b/src/globals.h index 63c1e73bea..30b676c8bd 100644 --- a/src/globals.h +++ b/src/globals.h @@ -294,7 +294,7 @@ const uint32_t kMaxAsciiCharCodeU = 0x7fu; // The USE(x) template is used to silence C++ compiler warnings // issued for (yet) unused variables (typically parameters). template -static inline void USE(T) { } +inline void USE(T) { } // FUNCTION_ADDR(f) gets the address of a C function f. diff --git a/src/hydrogen-instructions.h b/src/hydrogen-instructions.h index e2c5ff6104..52fed88442 100644 --- a/src/hydrogen-instructions.h +++ b/src/hydrogen-instructions.h @@ -3370,7 +3370,7 @@ class HLoadGlobalGeneric: public HTemplateInstruction<2> { }; -static inline bool StoringValueNeedsWriteBarrier(HValue* value) { +inline bool StoringValueNeedsWriteBarrier(HValue* value) { return !value->type().IsBoolean() && !value->type().IsSmi() && !(value->IsConstant() && HConstant::cast(value)->ImmortalImmovable()); diff --git a/src/ia32/frames-ia32.h b/src/ia32/frames-ia32.h index 32017ea54b..45b847aec4 100644 --- a/src/ia32/frames-ia32.h +++ b/src/ia32/frames-ia32.h @@ -34,24 +34,24 @@ namespace internal { // Register lists // 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 -static const RegList kJSCallerSaved = +const RegList kJSCallerSaved = 1 << 0 | // eax 1 << 1 | // ecx 1 << 2 | // edx 1 << 3 | // ebx - used as a caller-saved register in JavaScript code 1 << 7; // edi - callee function -static const int kNumJSCallerSaved = 5; +const int kNumJSCallerSaved = 5; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; // Number of registers for which space is reserved in safepoints. -static const int kNumSafepointRegisters = 8; +const int kNumSafepointRegisters = 8; // ---------------------------------------------------- diff --git a/src/ia32/macro-assembler-ia32.h b/src/ia32/macro-assembler-ia32.h index 6e6bda95ad..03ec28a8a1 100644 --- a/src/ia32/macro-assembler-ia32.h +++ b/src/ia32/macro-assembler-ia32.h @@ -881,26 +881,26 @@ class CodePatcher { // Static helper functions. // 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); } // Generate an Operand for loading an indexed field from an object. -static inline Operand FieldOperand(Register object, - Register index, - ScaleFactor scale, - int offset) { +inline Operand FieldOperand(Register object, + Register index, + ScaleFactor scale, + int offset) { 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)); } -static inline Operand GlobalObjectOperand() { +inline Operand GlobalObjectOperand() { return ContextOperand(esi, Context::GLOBAL_INDEX); } diff --git a/src/mips/constants-mips.h b/src/mips/constants-mips.h index d76ae59ff6..4f486c1c04 100644 --- a/src/mips/constants-mips.h +++ b/src/mips/constants-mips.h @@ -50,13 +50,13 @@ #if(defined(__mips_hard_float) && __mips_hard_float != 0) // Use floating-point coprocessor instructions. This flag is raised when // -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) // Not using floating-point coprocessor instructions. This flag is raised when // -msoft-float is passed to the compiler. -static const bool IsMipsSoftFloatABI = true; +const bool IsMipsSoftFloatABI = true; #else -static const bool IsMipsSoftFloatABI = true; +const bool IsMipsSoftFloatABI = true; #endif @@ -74,46 +74,45 @@ namespace internal { // Registers and FPURegisters. // Number of general purpose registers. -static const int kNumRegisters = 32; -static const int kInvalidRegister = -1; +const int kNumRegisters = 32; +const int kInvalidRegister = -1; // 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. -static const int kPCRegister = 34; +const int kPCRegister = 34; // Number coprocessor registers. -static const int kNumFPURegisters = 32; -static const int kInvalidFPURegister = -1; +const int kNumFPURegisters = 32; +const int kInvalidFPURegister = -1; // FPU (coprocessor 1) control registers. Currently only FCSR is implemented. -static const int kFCSRRegister = 31; -static const int kInvalidFPUControlRegister = -1; -static const uint32_t kFPUInvalidResult = (uint32_t) (1 << 31) - 1; +const int kFCSRRegister = 31; +const int kInvalidFPUControlRegister = -1; +const uint32_t kFPUInvalidResult = (uint32_t) (1 << 31) - 1; // FCSR constants. -static const uint32_t kFCSRInexactFlagBit = 2; -static const uint32_t kFCSRUnderflowFlagBit = 3; -static const uint32_t kFCSROverflowFlagBit = 4; -static const uint32_t kFCSRDivideByZeroFlagBit = 5; -static const uint32_t kFCSRInvalidOpFlagBit = 6; +const uint32_t kFCSRInexactFlagBit = 2; +const uint32_t kFCSRUnderflowFlagBit = 3; +const uint32_t kFCSROverflowFlagBit = 4; +const uint32_t kFCSRDivideByZeroFlagBit = 5; +const uint32_t kFCSRInvalidOpFlagBit = 6; -static const uint32_t kFCSRInexactFlagMask = 1 << kFCSRInexactFlagBit; -static const uint32_t kFCSRUnderflowFlagMask = 1 << kFCSRUnderflowFlagBit; -static const uint32_t kFCSROverflowFlagMask = 1 << kFCSROverflowFlagBit; -static const uint32_t kFCSRDivideByZeroFlagMask = 1 << kFCSRDivideByZeroFlagBit; -static const uint32_t kFCSRInvalidOpFlagMask = 1 << kFCSRInvalidOpFlagBit; +const uint32_t kFCSRInexactFlagMask = 1 << kFCSRInexactFlagBit; +const uint32_t kFCSRUnderflowFlagMask = 1 << kFCSRUnderflowFlagBit; +const uint32_t kFCSROverflowFlagMask = 1 << kFCSROverflowFlagBit; +const uint32_t kFCSRDivideByZeroFlagMask = 1 << kFCSRDivideByZeroFlagBit; +const uint32_t kFCSRInvalidOpFlagMask = 1 << kFCSRInvalidOpFlagBit; -static const uint32_t kFCSRFlagMask = +const uint32_t kFCSRFlagMask = kFCSRInexactFlagMask | kFCSRUnderflowFlagMask | kFCSROverflowFlagMask | kFCSRDivideByZeroFlagMask | kFCSRInvalidOpFlagMask; -static const uint32_t kFCSRExceptionFlagMask = - kFCSRFlagMask ^ kFCSRInexactFlagMask; +const uint32_t kFCSRExceptionFlagMask = kFCSRFlagMask ^ kFCSRInexactFlagMask; // Helper functions for converting between register numbers and names. class Registers { @@ -177,67 +176,66 @@ enum SoftwareInterruptCodes { // instructions (see Assembler::stop()). // - Breaks larger than kMaxStopCode are simple breaks, dropping you into the // debugger. -static const uint32_t kMaxWatchpointCode = 31; -static const uint32_t kMaxStopCode = 127; +const uint32_t kMaxWatchpointCode = 31; +const uint32_t kMaxStopCode = 127; STATIC_ASSERT(kMaxWatchpointCode < kMaxStopCode); // ----- Fields offset and length. -static const int kOpcodeShift = 26; -static const int kOpcodeBits = 6; -static const int kRsShift = 21; -static const int kRsBits = 5; -static const int kRtShift = 16; -static const int kRtBits = 5; -static const int kRdShift = 11; -static const int kRdBits = 5; -static const int kSaShift = 6; -static const int kSaBits = 5; -static const int kFunctionShift = 0; -static const int kFunctionBits = 6; -static const int kLuiShift = 16; +const int kOpcodeShift = 26; +const int kOpcodeBits = 6; +const int kRsShift = 21; +const int kRsBits = 5; +const int kRtShift = 16; +const int kRtBits = 5; +const int kRdShift = 11; +const int kRdBits = 5; +const int kSaShift = 6; +const int kSaBits = 5; +const int kFunctionShift = 0; +const int kFunctionBits = 6; +const int kLuiShift = 16; -static const int kImm16Shift = 0; -static const int kImm16Bits = 16; -static const int kImm26Shift = 0; -static const int kImm26Bits = 26; -static const int kImm28Shift = 0; -static const int kImm28Bits = 28; +const int kImm16Shift = 0; +const int kImm16Bits = 16; +const int kImm26Shift = 0; +const int kImm26Bits = 26; +const int kImm28Shift = 0; +const int kImm28Bits = 28; // In branches and jumps immediate fields point to words, not bytes, // and are therefore shifted by 2. -static const int kImmFieldShift = 2; +const int kImmFieldShift = 2; -static const int kFsShift = 11; -static const int kFsBits = 5; -static const int kFtShift = 16; -static const int kFtBits = 5; -static const int kFdShift = 6; -static const int kFdBits = 5; -static const int kFCccShift = 8; -static const int kFCccBits = 3; -static const int kFBccShift = 18; -static const int kFBccBits = 3; -static const int kFBtrueShift = 16; -static const int kFBtrueBits = 1; +const int kFsShift = 11; +const int kFsBits = 5; +const int kFtShift = 16; +const int kFtBits = 5; +const int kFdShift = 6; +const int kFdBits = 5; +const int kFCccShift = 8; +const int kFCccBits = 3; +const int kFBccShift = 18; +const int kFBccBits = 3; +const int kFBtrueShift = 16; +const int kFBtrueBits = 1; // ----- Miscellaneous useful masks. // Instruction bit masks. -static const int kOpcodeMask = ((1 << kOpcodeBits) - 1) << kOpcodeShift; -static const int kImm16Mask = ((1 << kImm16Bits) - 1) << kImm16Shift; -static const int kImm26Mask = ((1 << kImm26Bits) - 1) << kImm26Shift; -static const int kImm28Mask = ((1 << kImm28Bits) - 1) << kImm28Shift; -static const int kRsFieldMask = ((1 << kRsBits) - 1) << kRsShift; -static const int kRtFieldMask = ((1 << kRtBits) - 1) << kRtShift; -static const int kRdFieldMask = ((1 << kRdBits) - 1) << kRdShift; -static const int kSaFieldMask = ((1 << kSaBits) - 1) << kSaShift; -static const int kFunctionFieldMask = - ((1 << kFunctionBits) - 1) << kFunctionShift; +const int kOpcodeMask = ((1 << kOpcodeBits) - 1) << kOpcodeShift; +const int kImm16Mask = ((1 << kImm16Bits) - 1) << kImm16Shift; +const int kImm26Mask = ((1 << kImm26Bits) - 1) << kImm26Shift; +const int kImm28Mask = ((1 << kImm28Bits) - 1) << kImm28Shift; +const int kRsFieldMask = ((1 << kRsBits) - 1) << kRsShift; +const int kRtFieldMask = ((1 << kRtBits) - 1) << kRtShift; +const int kRdFieldMask = ((1 << kRdBits) - 1) << kRdShift; +const int kSaFieldMask = ((1 << kSaBits) - 1) << kSaShift; +const int kFunctionFieldMask = ((1 << kFunctionBits) - 1) << kFunctionShift; // Misc masks. -static const int kHiMask = 0xffff << 16; -static const int kLoMask = 0xffff; -static const int kSignMask = 0x80000000; -static const int kJumpAddrMask = (1 << (kImm26Bits + kImmFieldShift)) - 1; +const int kHiMask = 0xffff << 16; +const int kLoMask = 0xffff; +const int kSignMask = 0x80000000; +const int kJumpAddrMask = (1 << (kImm26Bits + kImmFieldShift)) - 1; // ----- MIPS Opcodes and Function Fields. // We use this presentation to stay close to the table representation in @@ -529,7 +527,7 @@ enum FPURoundingMode { kRoundToMinusInf = RM }; -static const uint32_t kFPURoundingModeMask = 3 << 0; +const uint32_t kFPURoundingModeMask = 3 << 0; enum CheckForInexactConversion { kCheckForInexactConversion, @@ -772,18 +770,18 @@ class Instruction { // MIPS assembly various constants. // C/C++ argument slots size. -static const int kCArgSlotCount = 4; -static const int kCArgsSlotsSize = kCArgSlotCount * Instruction::kInstrSize; +const int kCArgSlotCount = 4; +const int kCArgsSlotsSize = kCArgSlotCount * Instruction::kInstrSize; // JS argument slots size. -static const int kJSArgsSlotsSize = 0 * Instruction::kInstrSize; +const int kJSArgsSlotsSize = 0 * Instruction::kInstrSize; // 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; -static const int kDoubleAlignment = (1 << kDoubleAlignmentBits); -static const int kDoubleAlignmentMask = kDoubleAlignment - 1; +const int kDoubleAlignmentBits = 3; +const int kDoubleAlignment = (1 << kDoubleAlignmentBits); +const int kDoubleAlignmentMask = kDoubleAlignment - 1; } } // namespace v8::internal diff --git a/src/mips/frames-mips.h b/src/mips/frames-mips.h index ba6a230cee..9e626f3775 100644 --- a/src/mips/frames-mips.h +++ b/src/mips/frames-mips.h @@ -36,9 +36,9 @@ namespace internal { // Register lists. // Note that the bit values must match those used in actual instruction // encoding. -static const int kNumRegs = 32; +const int kNumRegs = 32; -static const RegList kJSCallerSaved = +const RegList kJSCallerSaved = 1 << 2 | // v0 1 << 3 | // v1 1 << 4 | // a0 @@ -54,7 +54,7 @@ static const RegList kJSCallerSaved = 1 << 14 | // t6 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 @@ -63,7 +63,7 @@ int JSCallerSavedCode(int n); // Callee-saved registers preserved when switching from C to JavaScript. -static const RegList kCalleeSaved = +const RegList kCalleeSaved = 1 << 16 | // s0 1 << 17 | // s1 1 << 18 | // s2 @@ -74,9 +74,9 @@ static const RegList kCalleeSaved = 1 << 23 | // s7 (cp in Javascript code) 1 << 30; // fp/s8 -static const int kNumCalleeSaved = 9; +const int kNumCalleeSaved = 9; -static const RegList kCalleeSavedFPU = +const RegList kCalleeSavedFPU = 1 << 20 | // f20 1 << 22 | // f22 1 << 24 | // f24 @@ -84,9 +84,9 @@ static const RegList kCalleeSavedFPU = 1 << 28 | // f28 1 << 30; // f30 -static const int kNumCalleeSavedFPU = 6; +const int kNumCalleeSavedFPU = 6; -static const RegList kCallerSavedFPU = +const RegList kCallerSavedFPU = 1 << 0 | // f0 1 << 2 | // f2 1 << 4 | // f4 @@ -101,20 +101,20 @@ static const RegList kCallerSavedFPU = // Number of registers for which space is reserved in safepoints. Must be a // multiple of 8. -static const int kNumSafepointRegisters = 24; +const int kNumSafepointRegisters = 24; // Define the list of registers actually saved at safepoints. // Note that the number of saved registers may be smaller than the reserved // space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters. -static const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved; -static const int kNumSafepointSavedRegisters = +const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved; +const int kNumSafepointSavedRegisters = kNumJSCallerSaved + kNumCalleeSaved; 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. -static const int kSafepointRegisterStackIndexMap[kNumRegs] = { +const int kSafepointRegisterStackIndexMap[kNumRegs] = { kUndefIndex, // zero_reg kUndefIndex, // at 0, // v0 diff --git a/src/mips/macro-assembler-mips.h b/src/mips/macro-assembler-mips.h index 5ff1c2d97b..6b2a5511ed 100644 --- a/src/mips/macro-assembler-mips.h +++ b/src/mips/macro-assembler-mips.h @@ -102,25 +102,25 @@ bool AreAliased(Register r1, Register r2, Register r3, Register r4); // ----------------------------------------------------------------------------- // Static helper functions. -static MemOperand ContextOperand(Register context, int index) { +inline MemOperand ContextOperand(Register context, int index) { return MemOperand(context, Context::SlotOffset(index)); } -static inline MemOperand GlobalObjectOperand() { +inline MemOperand GlobalObjectOperand() { return ContextOperand(cp, Context::GLOBAL_INDEX); } // 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); } // Generate a MemOperand for storing arguments 5..N on the stack // when calling CallCFunction(). -static inline MemOperand CFunctionArgumentOperand(int index) { +inline MemOperand CFunctionArgumentOperand(int index) { ASSERT(index > kCArgSlotCount); // Argument 5 takes the slot just past the four Arg-slots. int offset = (index - 5) * kPointerSize + kCArgsSlotsSize; diff --git a/src/objects.h b/src/objects.h index 7351d13331..6c88cc01ae 100644 --- a/src/objects.h +++ b/src/objects.h @@ -162,8 +162,7 @@ enum ElementsKind { LAST_ELEMENTS_KIND = EXTERNAL_PIXEL_ELEMENTS }; -static const int kElementsKindCount = - LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1; +const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1; void PrintElementsKind(FILE* out, ElementsKind kind); @@ -198,7 +197,7 @@ enum CreationFlag { // 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. @@ -650,8 +649,8 @@ enum InstanceType { NUM_OF_CALLABLE_SPEC_OBJECT_TYPES = 2 }; -static const int kExternalArrayTypeCount = LAST_EXTERNAL_ARRAY_TYPE - - FIRST_EXTERNAL_ARRAY_TYPE + 1; +const int kExternalArrayTypeCount = + LAST_EXTERNAL_ARRAY_TYPE - FIRST_EXTERNAL_ARRAY_TYPE + 1; STATIC_CHECK(JS_OBJECT_TYPE == Internals::kJSObjectType); STATIC_CHECK(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType); diff --git a/src/string-search.h b/src/string-search.h index 1223db0f98..f5405833ff 100644 --- a/src/string-search.h +++ b/src/string-search.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -242,9 +242,9 @@ int StringSearch::SingleCharSearch( template -static inline bool CharCompare(const PatternChar* pattern, - const SubjectChar* subject, - int length) { +inline bool CharCompare(const PatternChar* pattern, + const SubjectChar* subject, + int length) { ASSERT(length > 0); int pos = 0; do { @@ -555,10 +555,10 @@ int StringSearch::InitialSearch( // object should be constructed once and the Search function then called // for each search. template -static int SearchString(Isolate* isolate, - Vector subject, - Vector pattern, - int start_index) { +int SearchString(Isolate* isolate, + Vector subject, + Vector pattern, + int start_index) { StringSearch search(isolate, pattern); return search.Search(subject, start_index); } diff --git a/src/unicode.h b/src/unicode.h index 39fc349687..fb9e6339e1 100644 --- a/src/unicode.h +++ b/src/unicode.h @@ -1,4 +1,4 @@ -// 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 // modification, are permitted provided that the following conditions are // met: @@ -44,7 +44,7 @@ typedef unsigned char byte; * The max length of the result of converting the case of a single * character. */ -static const int kMaxMappingSize = 4; +const int kMaxMappingSize = 4; template class Predicate { diff --git a/src/utils.h b/src/utils.h index 2e6cfbd90d..68b1517de4 100644 --- a/src/utils.h +++ b/src/utils.h @@ -47,13 +47,13 @@ namespace internal { // 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). template -static inline bool IsPowerOf2(T x) { +inline bool IsPowerOf2(T x) { return IS_POWER_OF_TWO(x); } // 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(x != 0); int bits = 0; @@ -88,7 +88,7 @@ static inline int WhichPowerOf2(uint32_t x) { // The C++ standard leaves the semantics of '>>' undefined for // negative signed operands. Most implementations do the right thing, // though. -static inline int ArithmeticShiftRight(int x, int s) { +inline int ArithmeticShiftRight(int x, int s) { return x >> s; } @@ -97,7 +97,7 @@ static inline int ArithmeticShiftRight(int x, int s) { // This allows conversion of Addresses and integral types into // 0-relative int offsets. template -static inline intptr_t OffsetFrom(T x) { +inline intptr_t OffsetFrom(T x) { return x - static_cast(0); } @@ -106,14 +106,14 @@ static inline intptr_t OffsetFrom(T x) { // This allows conversion of 0-relative int offsets into Addresses and // integral types. template -static inline T AddressFrom(intptr_t x) { +inline T AddressFrom(intptr_t x) { return static_cast(static_cast(0) + x); } // Return the largest multiple of m which is <= x. template -static inline T RoundDown(T x, intptr_t m) { +inline T RoundDown(T x, intptr_t m) { ASSERT(IsPowerOf2(m)); return AddressFrom(OffsetFrom(x) & -m); } @@ -121,13 +121,13 @@ static inline T RoundDown(T x, intptr_t m) { // Return the smallest multiple of m which is >= x. template -static inline T RoundUp(T x, intptr_t m) { +inline T RoundUp(T x, intptr_t m) { return RoundDown(static_cast(x + m - 1), m); } template -static int Compare(const T& a, const T& b) { +int Compare(const T& a, const T& b) { if (a == b) return 0; else if (a < b) @@ -138,7 +138,7 @@ static int Compare(const T& a, const T& b) { template -static int PointerValueCompare(const T* a, const T* b) { +int PointerValueCompare(const T* a, const T* b) { return Compare(*a, *b); } @@ -148,7 +148,7 @@ static int PointerValueCompare(const T* a, const T* b) { // handles. template class Handle; // Forward declaration. template -static int HandleObjectPointerCompare(const Handle* a, const Handle* b) { +int HandleObjectPointerCompare(const Handle* a, const Handle* b) { return Compare(*(*a), *(*b)); } @@ -157,7 +157,7 @@ static int HandleObjectPointerCompare(const Handle* a, const Handle* b) { // number that is already a power of two, it is returned as is. // Implementation is from "Hacker's Delight" by Henry S. Warren, Jr., // 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); x = x - 1; x = x | (x >> 1); @@ -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); if (rounded_up > x) return rounded_up >> 1; return rounded_up; @@ -177,15 +177,15 @@ static inline uint32_t RoundDownToPowerOf2(uint32_t x) { template -static inline bool IsAligned(T value, U alignment) { +inline bool IsAligned(T value, U alignment) { return (value & (alignment - 1)) == 0; } // Returns true if (addr + offset) is aligned. -static inline bool IsAddressAligned(Address addr, - intptr_t alignment, - int offset = 0) { +inline bool IsAddressAligned(Address addr, + intptr_t alignment, + int offset = 0) { intptr_t offs = OffsetFrom(addr + offset); return IsAligned(offs, alignment); } @@ -193,14 +193,14 @@ static inline bool IsAddressAligned(Address addr, // Returns the maximum of the two parameters. template -static T Max(T a, T b) { +T Max(T a, T b) { return a < b ? b : a; } // Returns the minimum of the two parameters. template -static T Min(T a, T b) { +T Min(T a, T b) { return a < b ? a : b; } @@ -254,7 +254,7 @@ class BitField { // Thomas Wang, Integer Hash Functions. // 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; hash = ~hash + (hash << 15); // hash = (hash << 15) - hash - 1; hash = hash ^ (hash >> 12); @@ -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; hash = ~hash + (hash << 18); // hash = (hash << 18) - hash - 1; hash = hash ^ (hash >> 31); @@ -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( static_cast(reinterpret_cast(ptr))); } @@ -734,7 +734,7 @@ class SequenceCollector : public Collector { // Compare ASCII/16bit chars to ASCII/16bit chars. template -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; #ifdef V8_HOST_CAN_READ_UNALIGNED if (sizeof(*lhs) == sizeof(*rhs)) { @@ -761,7 +761,7 @@ static inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) { // Calculate 10^exponent. -static inline int TenToThe(int exponent) { +inline int TenToThe(int exponent) { ASSERT(exponent <= 9); ASSERT(exponent >= 1); int answer = 10; diff --git a/src/v8conversions.h b/src/v8conversions.h index 1840e3a34b..0147d8c371 100644 --- a/src/v8conversions.h +++ b/src/v8conversions.h @@ -34,13 +34,13 @@ namespace v8 { namespace internal { // 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(); 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(); return DoubleToUint32(number->Number()); } diff --git a/src/v8globals.h b/src/v8globals.h index b8bb658d8d..005cdbdaec 100644 --- a/src/v8globals.h +++ b/src/v8globals.h @@ -484,9 +484,9 @@ enum ScopeType { }; -static const uint32_t kHoleNanUpper32 = 0x7FFFFFFF; -static const uint32_t kHoleNanLower32 = 0xFFFFFFFF; -static const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000; +const uint32_t kHoleNanUpper32 = 0x7FFFFFFF; +const uint32_t kHoleNanLower32 = 0xFFFFFFFF; +const uint32_t kNaNOrInfinityLowerBoundUpper32 = 0x7FF00000; const uint64_t kHoleNanInt64 = (static_cast(kHoleNanUpper32) << 32) | kHoleNanLower32; diff --git a/src/v8utils.h b/src/v8utils.h index c854f04124..c73222a29b 100644 --- a/src/v8utils.h +++ b/src/v8utils.h @@ -143,7 +143,7 @@ inline void CopyWords(T* dst, T* src, int num_words) { template -static inline void MemsetPointer(T** dest, U* value, int counter) { +inline void MemsetPointer(T** dest, U* value, int counter) { #ifdef DEBUG T* a = NULL; U* b = NULL; @@ -202,7 +202,7 @@ Vector ReadFile(FILE* file, // Copy from ASCII/16bit chars to ASCII/16bit chars. template -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; #ifdef V8_HOST_CAN_READ_UNALIGNED if (sizeof(*dest) == sizeof(*src)) { diff --git a/src/x64/assembler-x64.h b/src/x64/assembler-x64.h index 0189c08507..1db5273b29 100644 --- a/src/x64/assembler-x64.h +++ b/src/x64/assembler-x64.h @@ -45,22 +45,22 @@ namespace internal { // Utility functions // 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); return static_cast(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); 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); 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); return x <= kMaxUInt32; } diff --git a/src/x64/frames-x64.h b/src/x64/frames-x64.h index 1db7429d0a..2626954ac6 100644 --- a/src/x64/frames-x64.h +++ b/src/x64/frames-x64.h @@ -31,20 +31,20 @@ namespace v8 { namespace internal { -static const int kNumRegs = 16; -static const RegList kJSCallerSaved = +const int kNumRegs = 16; +const RegList kJSCallerSaved = 1 << 0 | // rax 1 << 1 | // rcx 1 << 2 | // rdx 1 << 3 | // rbx - used as a caller-saved register in JavaScript code 1 << 7; // rdi - callee function -static const int kNumJSCallerSaved = 5; +const int kNumJSCallerSaved = 5; typedef Object* JSCallerSavedBuffer[kNumJSCallerSaved]; // Number of registers for which space is reserved in safepoints. -static const int kNumSafepointRegisters = 16; +const int kNumSafepointRegisters = 16; // ---------------------------------------------------- diff --git a/src/x64/macro-assembler-x64.h b/src/x64/macro-assembler-x64.h index e1823bf562..cf03e59e5e 100644 --- a/src/x64/macro-assembler-x64.h +++ b/src/x64/macro-assembler-x64.h @@ -50,14 +50,14 @@ enum AllocationFlags { // 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 // function calling convention. -static const Register kScratchRegister = { 10 }; // r10. -static const Register kSmiConstantRegister = { 12 }; // r12 (callee save). -static const Register kRootRegister = { 13 }; // r13 (callee save). +const Register kScratchRegister = { 10 }; // r10. +const Register kSmiConstantRegister = { 12 }; // r12 (callee save). +const Register kRootRegister = { 13 }; // r13 (callee save). // 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 // to take advantage of negitive 8-bit displacement values. -static const int kRootRegisterBias = 128; +const int kRootRegisterBias = 128; // Convenience for platform-independent signatures. typedef Operand MemOperand; @@ -1367,32 +1367,32 @@ class CodePatcher { // Static helper functions. // 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); } // Generate an Operand for loading an indexed field from an object. -static inline Operand FieldOperand(Register object, - Register index, - ScaleFactor scale, - int offset) { +inline Operand FieldOperand(Register object, + Register index, + ScaleFactor scale, + int offset) { 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)); } -static inline Operand GlobalObjectOperand() { +inline Operand GlobalObjectOperand() { return ContextOperand(rsi, Context::GLOBAL_INDEX); } // Provides access to exit frame stack space (not GCed). -static inline Operand StackSpaceOperand(int index) { +inline Operand StackSpaceOperand(int index) { #ifdef _WIN64 const int kShaddowSpace = 4; return Operand(rsp, (index + kShaddowSpace) * kPointerSize);