| // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| #include "vm/os.h" |
| |
| #include <errno.h> |
| #include <limits.h> |
| #include <time.h> |
| #include <sys/resource.h> |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include "platform/utils.h" |
| #include "vm/isolate.h" |
| |
| namespace dart { |
| |
| static bool LocalTime(int64_t seconds_since_epoch, tm* tm_result) { |
| time_t seconds = static_cast<time_t>(seconds_since_epoch); |
| if (seconds != seconds_since_epoch) return false; |
| struct tm* error_code = localtime_r(&seconds, tm_result); |
| return error_code != NULL; |
| } |
| |
| |
| const char* OS::GetTimeZoneName(int64_t seconds_since_epoch) { |
| tm decomposed; |
| bool succeeded = LocalTime(seconds_since_epoch, &decomposed); |
| // If unsuccessful, return an empty string like V8 does. |
| return (succeeded && (decomposed.tm_zone != NULL)) ? decomposed.tm_zone : ""; |
| } |
| |
| |
| int OS::GetTimeZoneOffsetInSeconds(int64_t seconds_since_epoch) { |
| tm decomposed; |
| bool succeeded = LocalTime(seconds_since_epoch, &decomposed); |
| // Even if the offset was 24 hours it would still easily fit into 32 bits. |
| // If unsuccessful, return zero like V8 does. |
| return succeeded ? static_cast<int>(decomposed.tm_gmtoff) : 0; |
| } |
| |
| |
| int OS::GetLocalTimeZoneAdjustmentInSeconds() { |
| // TODO(floitsch): avoid excessive calls to tzset? |
| tzset(); |
| // Even if the offset was 24 hours it would still easily fit into 32 bits. |
| // Note that Unix and Dart disagree on the sign. |
| return static_cast<int>(-timezone); |
| } |
| |
| |
| int64_t OS::GetCurrentTimeMillis() { |
| return GetCurrentTimeMicros() / 1000; |
| } |
| |
| |
| int64_t OS::GetCurrentTimeMicros() { |
| // gettimeofday has microsecond resolution. |
| struct timeval tv; |
| if (gettimeofday(&tv, NULL) < 0) { |
| UNREACHABLE(); |
| return 0; |
| } |
| return (static_cast<int64_t>(tv.tv_sec) * 1000000) + tv.tv_usec; |
| } |
| |
| |
| // TODO(5411554): May need to hoist these architecture dependent code |
| // into a architecture specific file e.g: os_ia32_linux.cc |
| word OS::ActivationFrameAlignment() { |
| #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) |
| const int kMinimumAlignment = 16; |
| #elif defined(TARGET_ARCH_ARM) |
| const int kMinimumAlignment = 8; |
| #else |
| #error Unsupported architecture. |
| #endif |
| word alignment = kMinimumAlignment; |
| // TODO(5411554): Allow overriding default stack alignment for |
| // testing purposes. |
| // Flags::DebugIsInt("stackalign", &alignment); |
| ASSERT(Utils::IsPowerOfTwo(alignment)); |
| ASSERT(alignment >= kMinimumAlignment); |
| return alignment; |
| } |
| |
| |
| word OS::PreferredCodeAlignment() { |
| #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64) |
| const int kMinimumAlignment = 16; |
| #elif defined(TARGET_ARCH_ARM) |
| const int kMinimumAlignment = 16; |
| #else |
| #error Unsupported architecture. |
| #endif |
| word alignment = kMinimumAlignment; |
| // TODO(5411554): Allow overriding default code alignment for |
| // testing purposes. |
| // Flags::DebugIsInt("codealign", &alignment); |
| ASSERT(Utils::IsPowerOfTwo(alignment)); |
| ASSERT(alignment >= kMinimumAlignment); |
| ASSERT(alignment <= OS::kMaxPreferredCodeAlignment); |
| return alignment; |
| } |
| |
| |
| uword OS::GetStackSizeLimit() { |
| struct rlimit stack_limit; |
| int retval = getrlimit(RLIMIT_STACK, &stack_limit); |
| ASSERT(retval == 0); |
| if (stack_limit.rlim_cur > INT_MAX) { |
| retval = INT_MAX; |
| } else { |
| retval = stack_limit.rlim_cur; |
| } |
| return retval; |
| } |
| |
| |
| int OS::NumberOfAvailableProcessors() { |
| return sysconf(_SC_NPROCESSORS_ONLN); |
| } |
| |
| |
| void OS::Sleep(int64_t millis) { |
| // TODO(5411554): For now just use usleep we may have to revisit this. |
| usleep(millis * 1000); |
| } |
| |
| |
| void OS::Print(const char* format, ...) { |
| va_list args; |
| va_start(args, format); |
| VFPrint(stdout, format, args); |
| va_end(args); |
| } |
| |
| |
| void OS::VFPrint(FILE* stream, const char* format, va_list args) { |
| vfprintf(stream, format, args); |
| fflush(stream); |
| } |
| |
| |
| int OS::SNPrint(char* str, size_t size, const char* format, ...) { |
| va_list args; |
| va_start(args, format); |
| int retval = VSNPrint(str, size, format, args); |
| va_end(args); |
| return retval; |
| } |
| |
| |
| int OS::VSNPrint(char* str, size_t size, const char* format, va_list args) { |
| int retval = vsnprintf(str, size, format, args); |
| if (retval < 0) { |
| FATAL1("Fatal error in OS::VSNPrint with format '%s'", format); |
| } |
| return retval; |
| } |
| |
| |
| bool OS::StringToInt64(const char* str, int64_t* value) { |
| ASSERT(str != NULL && strlen(str) > 0 && value != NULL); |
| int32_t base = 10; |
| char* endptr; |
| int i = 0; |
| if (str[0] == '-') { |
| i = 1; |
| } |
| if ((str[i] == '0') && |
| (str[i + 1] == 'x' || str[i + 1] == 'X') && |
| (str[i + 2] != '\0')) { |
| base = 16; |
| } |
| errno = 0; |
| *value = strtoll(str, &endptr, base); |
| return ((errno == 0) && (endptr != str) && (*endptr == 0)); |
| } |
| |
| |
| void OS::PrintErr(const char* format, ...) { |
| va_list args; |
| va_start(args, format); |
| VFPrint(stderr, format, args); |
| va_end(args); |
| } |
| |
| |
| void OS::InitOnce() { |
| // TODO(5411554): For now we check that initonce is called only once, |
| // Once there is more formal mechanism to call InitOnce we can move |
| // this check there. |
| static bool init_once_called = false; |
| ASSERT(init_once_called == false); |
| init_once_called = true; |
| } |
| |
| |
| void OS::Shutdown() { |
| } |
| |
| |
| void OS::Abort() { |
| abort(); |
| } |
| |
| |
| void OS::Exit(int code) { |
| exit(code); |
| } |
| |
| } // namespace dart |