diff options
author | The Android Open Source Project <initial-contribution@android.com> | 2008-10-21 07:00:00 -0700 |
---|---|---|
committer | The Android Open Source Project <initial-contribution@android.com> | 2008-10-21 07:00:00 -0700 |
commit | 2ad60cfc28e14ee8f0bb038720836a4696c478ad (patch) | |
tree | 19f1bb30ab7ff96f1e3e59a60b61dcd2aeddda93 /vm/Misc.h | |
download | android_dalvik-2ad60cfc28e14ee8f0bb038720836a4696c478ad.tar.gz android_dalvik-2ad60cfc28e14ee8f0bb038720836a4696c478ad.tar.bz2 android_dalvik-2ad60cfc28e14ee8f0bb038720836a4696c478ad.zip |
Initial Contribution
Diffstat (limited to 'vm/Misc.h')
-rw-r--r-- | vm/Misc.h | 274 |
1 files changed, 274 insertions, 0 deletions
diff --git a/vm/Misc.h b/vm/Misc.h new file mode 100644 index 000000000..95edc0f75 --- /dev/null +++ b/vm/Misc.h @@ -0,0 +1,274 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +/* + * Miscellaneous utility functions. + */ +#ifndef _DALVIK_MISC +#define _DALVIK_MISC + +#include "Inlines.h" + +#include <stdio.h> +#include <sys/types.h> +#include <sys/time.h> + +/* + * Used to shut up the compiler when a parameter isn't used. + */ +#define UNUSED_PARAMETER(p) (void)(p) + +/* + * Floating point conversion functions. These are necessary to avoid + * strict-aliasing problems ("dereferencing type-punned pointer will break + * strict-aliasing rules"). According to the gcc info page, this usage + * is allowed, even with "-fstrict-aliasing". + * + * The code generated by gcc-4.1.1 appears to be much better than a + * type cast dereference ("int foo = *(int*)&myfloat") when the conversion + * function is inlined. It also allows us to take advantage of the + * optimizations that strict aliasing rules allow. + */ +INLINE float dvmU4ToFloat(u4 val) { + union { u4 in; float out; } conv; + conv.in = val; + return conv.out; +} +INLINE u4 dvmFloatToU4(float val) { + union { float in; u4 out; } conv; + conv.in = val; + return conv.out; +} +#if 0 +INLINE float dvmU8ToFloat(u8 val) { + union { u8 in; float out; } conv; + conv.in = val; + return conv.out; +} +INLINE u8 dvmFloatToU8(float val) { + union { float in; u8 out; } conv; + conv.in = val; + return conv.out; +} +INLINE double dvmU8ToDouble(u8 val) { + union { u8 in; double out; } conv; + conv.in = val; + return conv.out; +} +INLINE u8 dvmDoubleToU8(double val) { + union { double in; u8 out; } conv; + conv.in = val; + return conv.out; +} +#endif + +/* + * Print a hex dump to the log file. + * + * "local" mode prints a hex dump starting from offset 0 (roughly equivalent + * to "xxd -g1"). + * + * "mem" mode shows the actual memory address, and will offset the start + * so that the low nibble of the address is always zero. + * + * If "tag" is NULL the default tag ("dalvikvm") will be used. + */ +typedef enum { kHexDumpLocal, kHexDumpMem } HexDumpMode; +void dvmPrintHexDumpEx(int priority, const char* tag, const void* vaddr, + size_t length, HexDumpMode mode); + +/* + * Print a hex dump, at INFO level. + */ +INLINE void dvmPrintHexDump(const void* vaddr, size_t length) { + dvmPrintHexDumpEx(ANDROID_LOG_INFO, LOG_TAG, + vaddr, length, kHexDumpLocal); +} + +/* + * Print a hex dump at VERBOSE level. This does nothing in non-debug builds. + */ +INLINE void dvmPrintHexDumpDbg(const void* vaddr, size_t length,const char* tag) +{ +#if !LOG_NDEBUG + dvmPrintHexDumpEx(ANDROID_LOG_VERBOSE, (tag != NULL) ? tag : LOG_TAG, + vaddr, length, kHexDumpLocal); +#endif +} + +/* + * We pass one of these around when we want code to be able to write debug + * info to either the log or to a file (or stdout/stderr). + */ +typedef struct DebugOutputTarget { + /* where to? */ + enum { + kDebugTargetUnknown = 0, + kDebugTargetLog, + kDebugTargetFile, + } which; + + /* additional bits */ + union { + struct { + int priority; + const char* tag; + } log; + struct { + FILE* fp; + } file; + } data; +} DebugOutputTarget; + +/* + * Fill in a DebugOutputTarget struct. + */ +void dvmCreateLogOutputTarget(DebugOutputTarget* target, int priority, + const char* tag); +void dvmCreateFileOutputTarget(DebugOutputTarget* target, FILE* fp); + +/* + * Print a debug message. + */ +void dvmPrintDebugMessage(const DebugOutputTarget* target, const char* format, + ...); + + +/* + * Expanding bitmap, used for tracking resources. Bits are numbered starting + * from zero. + */ +typedef struct BitVector { + bool expandable; /* expand bitmap if we run out? */ + int storageSize; /* current size, in 32-bit words */ + u4* storage; +} BitVector; + +/* allocate a bit vector with enough space to hold "startBits" bits */ +BitVector* dvmAllocBitVector(int startBits, bool expandable); +void dvmFreeBitVector(BitVector* pBits); + +/* + * Set/clear a single bit; assumes external synchronization. + * + * We always allocate the first possible bit. If we run out of space in + * the bitmap, and it's not marked expandable, dvmAllocBit returns -1. + */ +int dvmAllocBit(BitVector* pBits); +void dvmFreeBit(BitVector* pBits, int num); + +#define kBitVectorGrowth 4 /* increase by 4 u4s when limit hit */ + + +/* + * Return a newly-allocated string in which all occurrences of '.' have + * been changed to '/'. If we find a '/' in the original string, NULL + * is returned to avoid ambiguity. + */ +char* dvmDotToSlash(const char* str); + +/* + * Return a newly-allocated string for the "dot version" of the class + * name for the given type descriptor. That is, The initial "L" and + * final ";" (if any) have been removed and all occurrences of '/' + * have been changed to '.'. + */ +char* dvmDescriptorToDot(const char* str); + +/* + * Return a newly-allocated string for the type descriptor + * corresponding to the "dot version" of the given class name. That + * is, non-array names are surrounde by "L" and ";", and all + * occurrences of '.' have been changed to '/'. + */ +char* dvmDotToDescriptor(const char* str); + +/* + * Return a newly-allocated string for the internal-form class name for + * the given type descriptor. That is, the initial "L" and final ";" (if + * any) have been removed. + */ +char* dvmDescriptorToName(const char* str); + +/* + * Return a newly-allocated string for the type descriptor for the given + * internal-form class name. That is, a non-array class name will get + * surrounded by "L" and ";", while array names are left as-is. + */ +char* dvmNameToDescriptor(const char* str); + +/* + * Get the current time, in nanoseconds. This is "relative" time, meaning + * it could be wall-clock time or a monotonic counter, and is only suitable + * for computing time deltas. + */ +u8 dvmGetRelativeTimeNsec(void); + +/* + * Get the current time, in microseconds. This is "relative" time, meaning + * it could be wall-clock time or a monotonic counter, and is only suitable + * for computing time deltas. + */ +INLINE u8 dvmGetRelativeTimeUsec(void) { + return dvmGetRelativeTimeNsec() / 1000; +} + +/* + * Get the current per-thread CPU time. This clock increases monotonically + * when the thread is running, but not when it's sleeping or blocked on a + * synchronization object. + * + * The absolute value of the clock may not be useful, so this should only + * be used for time deltas. + * + * If the thread CPU clock is not available, this always returns (u8)-1. + */ +u8 dvmGetThreadCpuTimeNsec(void); + +/* + * Per-thread CPU time, in micros. + */ +INLINE u8 dvmGetThreadCpuTimeUsec(void) { + return dvmGetThreadCpuTimeNsec() / 1000; +} + +/* + * Like dvmGetThreadCpuTimeNsec, but for a different thread. + */ +u8 dvmGetOtherThreadCpuTimeNsec(pthread_t thread); +INLINE u8 dvmGetOtherThreadCpuTimeUsec(pthread_t thread) { + return dvmGetOtherThreadCpuTimeNsec(thread) / 1000; +} + +/* + * Sleep for increasingly longer periods, until "maxTotalSleep" microseconds + * have elapsed. Pass in the start time, which must be a value returned by + * dvmGetRelativeTimeUsec(). + * + * Returns "false" if we were unable to sleep because our time is up. + */ +bool dvmIterativeSleep(int iteration, int maxTotalSleep, u8 relStartTime); + +/* + * Set the "close on exec" flag on a file descriptor. + */ +bool dvmSetCloseOnExec(int fd); + +#if (!HAVE_STRLCPY) +/* Implementation of strlcpy() for platforms that don't already have it. */ +size_t strlcpy(char *dst, const char *src, size_t size); +#endif + +#endif /*_DALVIK_MISC*/ |