Get rid of uneeded extern, enum, typedef and struct qualifiers.
Change-Id: I236c5a1553a51f82c9bc3eaaab042046c854d3b4
diff --git a/dexdump/DexDump.cpp b/dexdump/DexDump.cpp
index 7d11752..59f149b 100644
--- a/dexdump/DexDump.cpp
+++ b/dexdump/DexDump.cpp
@@ -241,10 +241,10 @@
/*
* Flag for use with createAccessFlagStr().
*/
-typedef enum AccessFor {
+enum AccessFor {
kAccessForClass = 0, kAccessForMethod = 1, kAccessForField = 2,
kAccessForMAX
-} AccessFor;
+};
/*
* Create a new string with human-readable access flags.
diff --git a/vm/AllocTracker.h b/vm/AllocTracker.h
index fa8ba75..16d5168 100644
--- a/vm/AllocTracker.h
+++ b/vm/AllocTracker.h
@@ -19,16 +19,11 @@
#ifndef _DALVIK_ALLOCTRACKER
#define _DALVIK_ALLOCTRACKER
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* initialization */
bool dvmAllocTrackerStartup(void);
void dvmAllocTrackerShutdown(void);
struct AllocRecord;
-typedef struct AllocRecord AllocRecord;
/*
* Enable allocation tracking. Does nothing if tracking is already enabled.
@@ -64,8 +59,4 @@
*/
void dvmDumpTrackedAllocations(bool enable);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_ALLOCTRACKER*/
diff --git a/vm/Atomic.h b/vm/Atomic.h
index 713c5b4..9d43332 100644
--- a/vm/Atomic.h
+++ b/vm/Atomic.h
@@ -23,10 +23,6 @@
#include <cutils/atomic.h> /* use common Android atomic ops */
#include <cutils/atomic-inline.h> /* and some uncommon ones */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* NOTE: Two "quasiatomic" operations on the exact same memory address
* are guaranteed to operate atomically with respect to each other,
@@ -42,12 +38,12 @@
* Swap the 64-bit value at "addr" with "value". Returns the previous
* value.
*/
-int64_t dvmQuasiAtomicSwap64(int64_t value, volatile int64_t* addr);
+extern "C" int64_t dvmQuasiAtomicSwap64(int64_t value, volatile int64_t* addr);
/*
* Read the 64-bit value at "addr".
*/
-int64_t dvmQuasiAtomicRead64(volatile const int64_t* addr);
+extern "C" int64_t dvmQuasiAtomicRead64(volatile const int64_t* addr);
/*
* If the value at "addr" is equal to "oldvalue", replace it with "newvalue"
@@ -56,8 +52,4 @@
int dvmQuasiAtomicCas64(int64_t oldvalue, int64_t newvalue,
volatile int64_t* addr);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_ATOMIC*/
diff --git a/vm/AtomicCache.h b/vm/AtomicCache.h
index 2342162..29f1ebc 100644
--- a/vm/AtomicCache.h
+++ b/vm/AtomicCache.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_ATOMICCACHE
#define _DALVIK_ATOMICCACHE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* If set to "1", gather some stats on our caching success rate.
*/
@@ -35,12 +31,12 @@
*
* Must be exactly 16 bytes.
*/
-typedef struct AtomicCacheEntry {
+struct AtomicCacheEntry {
u4 key1;
u4 key2;
u4 value;
volatile u4 version; /* version and lock flag */
-} AtomicCacheEntry;
+};
/*
* One cache.
@@ -49,7 +45,7 @@
* struct and "entries" separately, avoiding an indirection. (We already
* handle "numEntries" separately in ATOMIC_CACHE_LOOKUP.)
*/
-typedef struct AtomicCache {
+struct AtomicCache {
AtomicCacheEntry* entries; /* array of entries */
int numEntries; /* #of entries, must be power of 2 */
@@ -61,7 +57,7 @@
int hits; /* found entry in cache */
int misses; /* entry was for other keys */
int fills; /* entry was empty */
-} AtomicCache;
+};
/*
* Do a cache lookup. We need to be able to read and write entries
@@ -174,8 +170,4 @@
*/
void dvmDumpAtomicCacheStats(const AtomicCache* pCache);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_ATOMICCACHE*/
diff --git a/vm/BitVector.h b/vm/BitVector.h
index 0d23350..01e2f1b 100644
--- a/vm/BitVector.h
+++ b/vm/BitVector.h
@@ -20,28 +20,24 @@
#ifndef _DALVIK_BITVECTOR
#define _DALVIK_BITVECTOR
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Expanding bitmap, used for tracking resources. Bits are numbered starting
* from zero.
*
* All operations on a BitVector are unsynchronized.
*/
-typedef struct BitVector {
+struct BitVector {
bool expandable; /* expand bitmap if we run out? */
u4 storageSize; /* current size, in 32-bit words */
u4* storage;
-} BitVector;
+};
/* Handy iterator to walk through the bit positions set to 1 */
-typedef struct BitVectorIterator {
+struct BitVectorIterator {
BitVector *pBits;
u4 idx;
u4 bitSize;
-} BitVectorIterator;
+};
/* allocate a bit vector with enough space to hold "startBits" bits */
BitVector* dvmAllocBitVector(unsigned int startBits, bool expandable);
@@ -104,8 +100,4 @@
/* Return the next position set to 1. -1 means end-of-vector reached */
int dvmBitVectorIteratorNext(BitVectorIterator* iterator);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_BITVECTOR*/
diff --git a/vm/Common.h b/vm/Common.h
index 0ec9ec4..637ed18 100644
--- a/vm/Common.h
+++ b/vm/Common.h
@@ -31,10 +31,6 @@
#include <endian.h>
#include "utils/Log.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#if !defined(NDEBUG) && defined(WITH_DALVIK_ASSERT)
# undef assert
# define assert(x) \
@@ -106,8 +102,4 @@
#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_COMMON*/
diff --git a/vm/Ddm.h b/vm/Ddm.h
index af7f6e1..01f5d18 100644
--- a/vm/Ddm.h
+++ b/vm/Ddm.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_DDM
#define _DALVIK_DDM
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Handle a packet full of DDM goodness.
*
@@ -88,8 +84,4 @@
*/
ArrayObject* dvmDdmGetRecentAllocations(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_DDM*/
diff --git a/vm/Debugger.cpp b/vm/Debugger.cpp
index ae3bb77..a9c8b98 100644
--- a/vm/Debugger.cpp
+++ b/vm/Debugger.cpp
@@ -153,9 +153,9 @@
/* keep track of type, in case we need to distinguish them someday */
-typedef enum RegistryType {
+enum RegistryType {
kObjectId = 0xc1, kRefTypeId
-} RegistryType;
+};
/*
* Hash function for object IDs. Since objects are at least 8 bytes, and
@@ -1282,12 +1282,12 @@
}
}
-typedef struct DebugCallbackContext {
+struct DebugCallbackContext {
int numItems;
ExpandBuf* pReply;
// used by locals table
bool withGeneric;
-} DebugCallbackContext;
+};
static int lineTablePositionsCb(void *cnxt, u4 address, u4 lineNum)
{
@@ -2570,8 +2570,8 @@
* The JDWP event mechanism has registered a single-step event. Tell
* the interpreter about it.
*/
-bool dvmDbgConfigureStep(ObjectId threadId, enum JdwpStepSize size,
- enum JdwpStepDepth depth)
+bool dvmDbgConfigureStep(ObjectId threadId, JdwpStepSize size,
+ JdwpStepDepth depth)
{
Object* threadObj;
Thread* thread;
@@ -2854,12 +2854,12 @@
}
// for dvmAddressSetForLine
-typedef struct AddressSetContext {
+struct AddressSetContext {
bool lastAddressValid;
u4 lastAddress;
u4 lineNum;
AddressSet *pSet;
-} AddressSetContext;
+};
// for dvmAddressSetForLine
static int addressSetCb (void *cnxt, u4 address, u4 lineNum)
diff --git a/vm/Debugger.h b/vm/Debugger.h
index dd9679f..aaef02d 100644
--- a/vm/Debugger.h
+++ b/vm/Debugger.h
@@ -26,10 +26,6 @@
#include "Misc.h"
#include "jdwp/Jdwp.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* fwd decl */
struct Object;
struct ClassObject;
@@ -40,10 +36,10 @@
* Used by StepControl to track a set of addresses associated with
* a single line.
*/
-typedef struct AddressSet {
+struct AddressSet {
u4 setSize;
u1 set[1];
-} AddressSet;
+};
INLINE void dvmAddressSetSet(AddressSet *pSet, u4 toSet)
{
@@ -64,24 +60,24 @@
/*
* Single-step management.
*/
-typedef struct StepControl {
+struct StepControl {
/* request */
- enum JdwpStepSize size;
- enum JdwpStepDepth depth;
- struct Thread* thread; /* don't deref; for comparison only */
+ JdwpStepSize size;
+ JdwpStepDepth depth;
+ Thread* thread; /* don't deref; for comparison only */
/* current state */
- bool active;
- const struct Method* method;
- int line; /* line #; could be -1 */
- const AddressSet* pAddressSet; /* if non-null, address set for line */
- int frameDepth;
-} StepControl;
+ bool active;
+ const Method* method;
+ int line; /* line #; could be -1 */
+ const AddressSet* pAddressSet; /* if non-null, address set for line */
+ int frameDepth;
+};
/*
* Invoke-during-breakpoint support.
*/
-typedef struct DebugInvokeReq {
+struct DebugInvokeReq {
/* boolean; only set when we're in the tail end of an event handler */
bool ready;
@@ -89,24 +85,24 @@
bool invokeNeeded;
/* request */
- struct Object* obj; /* not used for ClassType.InvokeMethod */
- struct Object* thread;
- struct ClassObject* clazz;
- struct Method* method;
- u4 numArgs;
- u8* argArray; /* will be NULL if numArgs==0 */
- u4 options;
+ Object* obj; /* not used for ClassType.InvokeMethod */
+ Object* thread;
+ ClassObject* clazz;
+ Method* method;
+ u4 numArgs;
+ u8* argArray; /* will be NULL if numArgs==0 */
+ u4 options;
/* result */
- JdwpError err;
- u1 resultTag;
- JValue resultValue;
- ObjectId exceptObj;
+ JdwpError err;
+ u1 resultTag;
+ JValue resultValue;
+ ObjectId exceptObj;
/* condition variable to wait on while the method executes */
- pthread_mutex_t lock;
- pthread_cond_t cv;
-} DebugInvokeReq;
+ pthread_mutex_t lock;
+ pthread_cond_t cv;
+};
/* system init/shutdown */
bool dvmDebuggerStartup(void);
@@ -264,14 +260,13 @@
/*
* Debugger notification
*/
-void dvmDbgPostLocationEvent(const struct Method* method, int pcOffset,
- struct Object* thisPtr, int eventFlags);
+void dvmDbgPostLocationEvent(const Method* method, int pcOffset,
+ Object* thisPtr, int eventFlags);
void dvmDbgPostException(void* throwFp, int throwRelPc, void* catchFp,
- int catchRelPc, struct Object* exception);
-void dvmDbgPostThreadStart(struct Thread* thread);
-void dvmDbgPostThreadDeath(struct Thread* thread);
-void dvmDbgPostClassPrepare(struct ClassObject* clazz);
-// FieldAccess, FieldModification
+ int catchRelPc, Object* exception);
+void dvmDbgPostThreadStart(Thread* thread);
+void dvmDbgPostThreadDeath(Thread* thread);
+void dvmDbgPostClassPrepare(ClassObject* clazz);
/* for "eventFlags" */
enum {
@@ -283,8 +278,8 @@
bool dvmDbgWatchLocation(const JdwpLocation* pLoc);
void dvmDbgUnwatchLocation(const JdwpLocation* pLoc);
-bool dvmDbgConfigureStep(ObjectId threadId, enum JdwpStepSize size,
- enum JdwpStepDepth depth);
+bool dvmDbgConfigureStep(ObjectId threadId, JdwpStepSize size,
+ JdwpStepDepth depth);
void dvmDbgUnconfigureStep(ObjectId threadId);
JdwpError dvmDbgInvokeMethod(ObjectId threadId, ObjectId objectId,
@@ -293,7 +288,7 @@
void dvmDbgExecuteMethod(DebugInvokeReq* pReq);
/* Make an AddressSet for a line, for single stepping */
-const AddressSet *dvmAddressSetForLine(const struct Method* method, int line);
+const AddressSet *dvmAddressSetForLine(const Method* method, int line);
/* perform "late registration" of an object ID */
void dvmDbgRegisterObjectId(ObjectId id);
@@ -311,8 +306,4 @@
#define CHUNK_TYPE(_name) \
((_name)[0] << 24 | (_name)[1] << 16 | (_name)[2] << 8 | (_name)[3])
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_DEBUGGER*/
diff --git a/vm/DvmDex.h b/vm/DvmDex.h
index 937f09d..df14760 100644
--- a/vm/DvmDex.h
+++ b/vm/DvmDex.h
@@ -21,10 +21,6 @@
#ifndef _DALVIK_DVMDEX
#define _DALVIK_DVMDEX
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#include "libdex/DexFile.h"
/* extern */
@@ -38,7 +34,7 @@
/*
* Some additional VM data structures that are associated with the DEX file.
*/
-typedef struct DvmDex {
+struct DvmDex {
/* pointer to the DexFile we're associated with */
DexFile* pDexFile;
@@ -67,7 +63,7 @@
/* lock ensuring mutual exclusion during updates */
pthread_mutex_t modLock;
-} DvmDex;
+};
/*
@@ -162,8 +158,4 @@
pDvmDex->pResFields[fieldIdx] = field;
}
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_DVMDEX*/
diff --git a/vm/Exception.h b/vm/Exception.h
index 24c0eb4..81a0e76 100644
--- a/vm/Exception.h
+++ b/vm/Exception.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_EXCEPTION
#define _DALVIK_EXCEPTION
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Create a Throwable and throw an exception in the current thread (where
* "throwing" just means "set the thread's exception pointer").
@@ -177,7 +173,7 @@
* Returns the offset to the catch code on success, or -1 if we couldn't
* find a catcher.
*/
-int dvmFindCatchBlock(Thread* self, int relPc, Object* exception,
+extern "C" int dvmFindCatchBlock(Thread* self, int relPc, Object* exception,
bool doUnroll, void** newFrame);
/*
@@ -216,21 +212,20 @@
* Throw an ArithmeticException in the current thread, with the given detail
* message.
*/
-void dvmThrowArithmeticException(const char* msg);
+extern "C" void dvmThrowArithmeticException(const char* msg);
/*
* Throw an ArrayIndexOutOfBoundsException in the current thread,
* using the given array length and index in the detail message.
*/
-void dvmThrowArrayIndexOutOfBoundsException(int length, int index);
+extern "C" void dvmThrowArrayIndexOutOfBoundsException(int length, int index);
/*
* Throw an ArrayStoreException in the current thread, using the given classes'
* names in the detail message, indicating that an object of the given type
* can't be stored into an array of the given type.
*/
-void dvmThrowArrayStoreExceptionIncompatibleElement(ClassObject* objectType,
- ClassObject* arrayType);
+extern "C" void dvmThrowArrayStoreExceptionIncompatibleElement(ClassObject* objectType, ClassObject* arrayType);
/*
* Throw an ArrayStoreException in the current thread, using the given
@@ -259,7 +254,7 @@
* Throw a ClassCastException in the current thread, using the given classes'
* names in the detail message.
*/
-void dvmThrowClassCastException(ClassObject* actual, ClassObject* desired);
+extern "C" void dvmThrowClassCastException(ClassObject* actual, ClassObject* desired);
/**
* Throw a ClassCircularityError in the current thread, with the
@@ -365,7 +360,7 @@
* Throw an InternalError in the current thread, with the given
* detail message.
*/
-void dvmThrowInternalError(const char* msg);
+extern "C" void dvmThrowInternalError(const char* msg);
/**
* Throw an InterruptedException in the current thread, with the given
@@ -383,13 +378,13 @@
* Throw a NegativeArraySizeException in the current thread, with the
* given number as the detail message.
*/
-void dvmThrowNegativeArraySizeException(s4 size);
+extern "C" void dvmThrowNegativeArraySizeException(s4 size);
/**
* Throw a NoClassDefFoundError in the current thread, with the
* human-readable form of the given descriptor as the detail message.
*/
-void dvmThrowNoClassDefFoundError(const char* descriptor);
+extern "C" void dvmThrowNoClassDefFoundError(const char* descriptor);
/**
* Throw a NoClassDefFoundError in the current thread, with the given
@@ -403,7 +398,7 @@
* Throw a NoSuchFieldError in the current thread, with the given
* detail message.
*/
-void dvmThrowNoSuchFieldError(const char* msg);
+extern "C" void dvmThrowNoSuchFieldError(const char* msg);
/**
* Throw a NoSuchFieldException in the current thread, with the given
@@ -415,13 +410,13 @@
* Throw a NoSuchMethodError in the current thread, with the given
* detail message.
*/
-void dvmThrowNoSuchMethodError(const char* msg);
+extern "C" void dvmThrowNoSuchMethodError(const char* msg);
/**
* Throw a NullPointerException in the current thread, with the given
* detail message.
*/
-void dvmThrowNullPointerException(const char* msg);
+extern "C" void dvmThrowNullPointerException(const char* msg);
/**
* Throw an OutOfMemoryError in the current thread, with the given
@@ -487,8 +482,4 @@
*/
void dvmThrowVirtualMachineError(const char* msg);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_EXCEPTION*/
diff --git a/vm/Globals.h b/vm/Globals.h
index 6b5d786..db552c6 100644
--- a/vm/Globals.h
+++ b/vm/Globals.h
@@ -33,24 +33,20 @@
#include <stdarg.h>
#include <pthread.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* private structures */
-typedef struct GcHeap GcHeap;
-typedef struct BreakpointSet BreakpointSet;
-typedef struct InlineSub InlineSub;
+struct GcHeap;
+struct BreakpointSet;
+struct InlineSub;
/*
* One of these for each -ea/-da/-esa/-dsa on the command line.
*/
-typedef struct AssertionControl {
+struct AssertionControl {
char* pkgOrClass; /* package/class string, or NULL for esa/dsa */
int pkgOrClassLen; /* string length, for quick compare */
bool enable; /* enable or disable */
bool isPackage; /* string ended with "..."? */
-} AssertionControl;
+};
/*
* Register map generation mode. Only applicable when generateRegisterMaps
@@ -62,11 +58,11 @@
* maps, but allows type-precise GC. "LivePrecise" is even slower and
* requires additional heap during processing, but allows live-precise GC.
*/
-typedef enum {
+enum RegisterMapMode {
kRegisterMapModeUnknown = 0,
kRegisterMapModeTypePrecise,
kRegisterMapModeLivePrecise
-} RegisterMapMode;
+};
/*
* All fields are initialized to zero.
@@ -723,25 +719,25 @@
#if defined(WITH_JIT)
/* Trace profiling modes. Ordering matters - off states before on states */
-typedef enum TraceProfilingModes {
+enum TraceProfilingModes {
kTraceProfilingDisabled = 0, // Not profiling
kTraceProfilingPeriodicOff = 1, // Periodic profiling, off phase
kTraceProfilingContinuous = 2, // Always profiling
kTraceProfilingPeriodicOn = 3 // Periodic profiling, on phase
-} TraceProfilingModes;
+};
/*
* Exiting the compiled code w/o chaining will incur overhead to look up the
* target in the code cache which is extra work only when JIT is enabled. So
* we want to monitor it closely to make sure we don't have performance bugs.
*/
-typedef enum NoChainExits {
+enum NoChainExits {
kInlineCacheMiss = 0,
kCallsiteInterpreted,
kSwitchOverflow,
kHeavyweightMonitor,
kNoChainExitLast,
-} NoChainExits;
+};
/*
* JIT-specific global state
@@ -968,8 +964,4 @@
extern struct DvmJniGlobals gDvmJni;
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_GLOBALS*/
diff --git a/vm/Hash.h b/vm/Hash.h
index 2c6bd5e..12af8a7 100644
--- a/vm/Hash.h
+++ b/vm/Hash.h
@@ -22,10 +22,6 @@
#ifndef _DALVIK_HASH
#define _DALVIK_HASH
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* compute the hash of an item with a specific type */
typedef u4 (*HashCompute)(const void* item);
@@ -62,10 +58,10 @@
*
* When an entry is released, we will call (HashFreeFunc)(entry->data).
*/
-typedef struct HashEntry {
+struct HashEntry {
u4 hashValue;
void* data;
-} HashEntry;
+};
#define HASH_TOMBSTONE ((void*) 0xcbcacccd) // invalid ptr value
@@ -74,14 +70,14 @@
*
* This structure should be considered opaque.
*/
-typedef struct HashTable {
+struct HashTable {
int tableSize; /* must be power of 2 */
int numEntries; /* current #of "live" entries */
int numDeadEntries; /* current #of tombstone entries */
HashEntry* pEntries; /* array on heap */
HashFreeFunc freeFunc;
pthread_mutex_t lock;
-} HashTable;
+};
/*
* Create and initialize a HashTable structure, using "initialSize" as
@@ -183,11 +179,11 @@
* MyData* data = (MyData*)dvmHashIterData(&iter);
* }
*/
-typedef struct HashIter {
+struct HashIter {
void* data;
HashTable* pHashTable;
int idx;
-} HashIter;
+};
INLINE void dvmHashIterNext(HashIter* pIter) {
int i = pIter->idx +1;
int lim = pIter->pHashTable->tableSize;
@@ -222,8 +218,4 @@
void dvmHashTableProbeCount(HashTable* pHashTable, HashCalcFunc calcFunc,
HashCompareFunc cmpFunc);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_HASH*/
diff --git a/vm/IndirectRefTable.h b/vm/IndirectRefTable.h
index 36d18ba..165bfb1 100644
--- a/vm/IndirectRefTable.h
+++ b/vm/IndirectRefTable.h
@@ -17,10 +17,6 @@
#ifndef _DALVIK_INDIRECTREFTABLE
#define _DALVIK_INDIRECTREFTABLE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Maintain a table of indirect references. Used for local/global JNI
* references.
@@ -95,22 +91,22 @@
*
* For convenience these match up with enum jobjectRefType from jni.h.
*/
-typedef enum IndirectRefKind {
+enum IndirectRefKind {
kIndirectKindInvalid = 0,
kIndirectKindLocal = 1,
kIndirectKindGlobal = 2,
kIndirectKindWeakGlobal = 3
-} IndirectRefKind;
+};
/*
* Extended debugging structure. We keep a parallel array of these, one
* per slot in the table.
*/
#define kIRTPrevCount 4
-typedef struct IndirectRefSlot {
+struct IndirectRefSlot {
u4 serial; /* slot serial */
Object* previous[kIRTPrevCount];
-} IndirectRefSlot;
+};
/*
* Table definition.
@@ -179,14 +175,14 @@
* add a "synchronized lookup" call that takes the mutex as an argument,
* and either locks or doesn't lock based on internal details.
*/
-typedef union IRTSegmentState {
+union IRTSegmentState {
u4 all;
struct {
u4 topIndex:16; /* index of first unused entry */
u4 numHoles:16; /* #of holes in entire table */
} parts;
-} IRTSegmentState;
-typedef struct IndirectRefTable {
+};
+struct IndirectRefTable {
/* semi-public - read/write by interpreter in native call handler */
IRTSegmentState segmentState;
@@ -201,7 +197,7 @@
// TODO: want hole-filling stats (#of holes filled, total entries scanned)
// for performance evaluation.
-} IndirectRefTable;
+};
/* use as initial value for "cookie", and when table has only one segment */
#define IRT_FIRST_SEGMENT 0
@@ -394,8 +390,4 @@
*/
void dvmDumpIndirectRefTable(const IndirectRefTable* pRef, const char* descr);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INDIRECTREFTABLE*/
diff --git a/vm/Init.h b/vm/Init.h
index 7e91217..4d85c2e 100644
--- a/vm/Init.h
+++ b/vm/Init.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_INIT
#define _DALVIK_INIT
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Standard VM initialization, usually invoked through JNI.
*/
@@ -73,8 +69,4 @@
#endif
;
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INIT*/
diff --git a/vm/InlineNative.cpp b/vm/InlineNative.cpp
index 8e538cc..f4f4e8c 100644
--- a/vm/InlineNative.cpp
+++ b/vm/InlineNative.cpp
@@ -511,16 +511,16 @@
* ===========================================================================
*/
-typedef union {
+union Convert32 {
u4 arg;
float ff;
-} Convert32;
+};
-typedef union {
+union Convert64 {
u4 arg[2];
s8 ll;
double dd;
-} Convert64;
+};
/*
* public static int abs(int)
diff --git a/vm/InlineNative.h b/vm/InlineNative.h
index bf08412..64caec9 100644
--- a/vm/InlineNative.h
+++ b/vm/InlineNative.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_INLINENATIVE
#define _DALVIK_INLINENATIVE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* startup/shutdown */
bool dvmInlineNativeStartup(void);
void dvmInlineNativeShutdown(void);
@@ -49,19 +45,19 @@
* generate assembly code that knows how many args it needs and has the
* target address embedded.
*/
-typedef struct InlineOperation {
+struct InlineOperation {
InlineOp4Func func; /* MUST be first entry */
const char* classDescriptor;
const char* methodName;
const char* methodSignature;
-} InlineOperation;
+};
/*
* Must be kept in sync w/ gDvmInlineOpsTable in InlineNative.c
*
* You should also add a test to libcore's IntrinsicTest.
*/
-typedef enum NativeInlineOps {
+enum NativeInlineOps {
INLINE_EMPTYINLINEMETHOD = 0,
INLINE_STRING_CHARAT = 1,
INLINE_STRING_COMPARETO = 2,
@@ -84,7 +80,7 @@
INLINE_DOUBLE_TO_LONG_BITS = 19,
INLINE_DOUBLE_TO_RAW_LONG_BITS = 20,
INLINE_LONG_BITS_TO_DOUBLE = 21,
-} NativeInlineOps;
+};
/*
* Get the inlineops table.
@@ -123,7 +119,7 @@
/*
* Return method & populate the table on first use.
*/
-Method* dvmResolveInlineNative(int opIndex);
+extern "C" Method* dvmResolveInlineNative(int opIndex);
/*
* The actual inline native definitions.
@@ -194,8 +190,4 @@
bool javaLangDouble_longBitsToDouble(u4 arg0, u4 arg1, u4 arg2, u4 arg,
JValue* pResult);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INLINENATIVE*/
diff --git a/vm/Intern.h b/vm/Intern.h
index b6e669a..6630b69 100644
--- a/vm/Intern.h
+++ b/vm/Intern.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_INTERN
#define _DALVIK_INTERN
-#ifdef __cplusplus
-extern "C" {
-#endif
-
bool dvmStringInternStartup(void);
void dvmStringInternShutdown(void);
StringObject* dvmLookupInternedString(StringObject* strObj);
@@ -30,8 +26,4 @@
bool dvmIsWeakInternedString(const StringObject* strObj);
void dvmGcDetachDeadInternedStrings(int (*isUnmarkedObject)(void *));
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INTERN*/
diff --git a/vm/JarFile.h b/vm/JarFile.h
index 0569ee2..e199951 100644
--- a/vm/JarFile.h
+++ b/vm/JarFile.h
@@ -19,20 +19,16 @@
#ifndef _DALVIK_JARFILE
#define _DALVIK_JARFILE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* This represents an open, scanned Jar file. (It's actually for any Zip
* archive that happens to hold a Dex file.)
*/
-typedef struct JarFile {
+struct JarFile {
ZipArchive archive;
//MemMapping map;
char* cacheFileName;
DvmDex* pDvmDex;
-} JarFile;
+};
/*
* Open the Zip archive and get a list of the classfile entries.
@@ -58,13 +54,13 @@
return pJarFile->cacheFileName;
}
-typedef enum DexCacheStatus {
+enum DexCacheStatus {
DEX_CACHE_ERROR = -2,
DEX_CACHE_BAD_ARCHIVE = -1,
DEX_CACHE_OK = 0,
DEX_CACHE_STALE,
DEX_CACHE_STALE_ODEX,
-} DexCacheStatus;
+};
/*
* Checks the dependencies of the dex cache file corresponding
@@ -72,8 +68,4 @@
*/
DexCacheStatus dvmDexCacheStatus(const char *fileName);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JARFILE*/
diff --git a/vm/JniInternal.h b/vm/JniInternal.h
index 173583d..9412ab8 100644
--- a/vm/JniInternal.h
+++ b/vm/JniInternal.h
@@ -21,10 +21,6 @@
#include "jni.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* system init/shutdown */
bool dvmJniStartup(void);
void dvmJniShutdown(void);
@@ -36,7 +32,7 @@
*/
struct JavaVMExt;
-typedef struct JNIEnvExt {
+struct JNIEnvExt {
const struct JNINativeInterface* funcTable; /* must be first */
const struct JNINativeInterface* baseFuncTable;
@@ -49,9 +45,9 @@
struct JNIEnvExt* prev;
struct JNIEnvExt* next;
-} JNIEnvExt;
+};
-typedef struct JavaVMExt {
+struct JavaVMExt {
const struct JNIInvokeInterface* funcTable; /* must be first */
const struct JNIInvokeInterface* baseFuncTable;
@@ -59,7 +55,7 @@
/* head of list of JNIEnvs associated with this VM */
JNIEnvExt* envList;
pthread_mutex_t envListLock;
-} JavaVMExt;
+};
/*
* Native function return type; used by dvmPlatformInvoke().
@@ -68,7 +64,7 @@
* Note: Assembly code in arch/<arch>/Call<arch>.S relies on
* the enum values defined here.
*/
-typedef enum DalvikJniReturnType {
+enum DalvikJniReturnType {
DALVIK_JNI_RETURN_VOID = 0, /* must be zero */
DALVIK_JNI_RETURN_FLOAT = 1,
DALVIK_JNI_RETURN_DOUBLE = 2,
@@ -77,7 +73,7 @@
DALVIK_JNI_RETURN_S2 = 5,
DALVIK_JNI_RETURN_U2 = 6,
DALVIK_JNI_RETURN_S1 = 7
-} DalvikJniReturnType;
+};
#define DALVIK_JNI_NO_ARG_INFO 0x80000000
#define DALVIK_JNI_RETURN_MASK 0x70000000
@@ -188,8 +184,4 @@
*/
void dvmDumpJniReferenceTables(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JNIINTERNAL*/
diff --git a/vm/LinearAlloc.h b/vm/LinearAlloc.h
index c06d2ab..3305e5b 100644
--- a/vm/LinearAlloc.h
+++ b/vm/LinearAlloc.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_LINEARALLOC
#define _DALVIK_LINEARALLOC
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* If this is set, we create additional data structures and make many
* additional mprotect() calls.
@@ -34,7 +30,7 @@
* allocated region, but that would prevent us from sharing the rest of
* that first page.
*/
-typedef struct LinearAllocHdr {
+struct LinearAllocHdr {
int curOffset; /* offset where next data goes */
pthread_mutex_t lock; /* controls updates to this struct */
@@ -43,7 +39,7 @@
int firstOffset; /* for chasing through */
short* writeRefCount; /* for ENFORCE_READ_ONLY */
-} LinearAllocHdr;
+};
/*
@@ -121,8 +117,4 @@
*/
bool dvmLinearAllocContains(const void* start, size_t length);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_LINEARALLOC*/
diff --git a/vm/Misc.h b/vm/Misc.h
index c1ab72c..6bce241 100644
--- a/vm/Misc.h
+++ b/vm/Misc.h
@@ -25,10 +25,6 @@
#include <sys/time.h>
#include "Inlines.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Used to shut up the compiler when a parameter isn't used.
*/
@@ -67,7 +63,7 @@
*
* If "tag" is NULL the default tag ("dalvikvm") will be used.
*/
-typedef enum { kHexDumpLocal, kHexDumpMem } HexDumpMode;
+enum HexDumpMode { kHexDumpLocal, kHexDumpMem };
void dvmPrintHexDumpEx(int priority, const char* tag, const void* vaddr,
size_t length, HexDumpMode mode);
@@ -90,17 +86,17 @@
#endif
}
-typedef enum {
+enum DebugTargetKind {
kDebugTargetUnknown = 0,
kDebugTargetLog,
kDebugTargetFile,
-} DebugTargetKind;
+};
/*
* 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 {
+struct DebugOutputTarget {
/* where to? */
DebugTargetKind which;
@@ -114,7 +110,7 @@
FILE* fp;
} file;
} data;
-} DebugOutputTarget;
+};
/*
* Fill in a DebugOutputTarget struct.
@@ -145,7 +141,7 @@
* of 'descriptor'. So "I" would be "int", "[[I" would be "int[][]",
* "[Ljava/lang/String;" would be "java.lang.String[]", and so forth.
*/
-char* dvmHumanReadableDescriptor(const char* descriptor);
+extern "C" char* dvmHumanReadableDescriptor(const char* descriptor);
/*
* Return a newly-allocated string for the "dot version" of the class
@@ -260,7 +256,7 @@
* get from the abort may point at the wrong call site. Best to leave
* it undecorated.
*/
-void dvmAbort(void);
+extern "C" void dvmAbort(void);
void dvmPrintNativeBackTrace(void);
#if (!HAVE_STRLCPY)
@@ -278,11 +274,11 @@
/*
* Get some per-thread stats from /proc/self/task/N/stat.
*/
-typedef struct {
+struct ProcStatData {
unsigned long utime; /* number of jiffies scheduled in user mode */
unsigned long stime; /* number of jiffies scheduled in kernel mode */
int processor; /* number of CPU that last executed thread */
-} ProcStatData;
+};
bool dvmGetThreadStats(ProcStatData* pData, pid_t tid);
/*
@@ -304,8 +300,4 @@
*/
const char* dvmPathToAbsolutePortion(const char* path);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_MISC*/
diff --git a/vm/Native.cpp b/vm/Native.cpp
index 7d7980b..bbb4ce6 100644
--- a/vm/Native.cpp
+++ b/vm/Native.cpp
@@ -137,17 +137,17 @@
// are associated with it. (Or not -- can't determine if native code
// is still using parts of it.)
-typedef enum OnLoadState {
+enum OnLoadState {
kOnLoadPending = 0, /* initial state, must be zero */
kOnLoadFailed,
kOnLoadOkay,
-} OnLoadState;
+};
/*
* We add one of these to the hash table for every library we load. The
* hash is on the "pathName" field.
*/
-typedef struct SharedLib {
+struct SharedLib {
char* pathName; /* absolute path to library */
void* handle; /* from dlopen */
Object* classLoader; /* ClassLoader we are associated with */
@@ -156,7 +156,7 @@
pthread_cond_t onLoadCond; /* wait for JNI_OnLoad in other thread */
u4 onLoadThreadId; /* recursive invocation guard */
OnLoadState onLoadResult; /* result of earlier JNI_OnLoad */
-} SharedLib;
+};
/*
* (This is a dvmHashTableLookup callback.)
diff --git a/vm/Native.h b/vm/Native.h
index 7599bcc..eb2b84a 100644
--- a/vm/Native.h
+++ b/vm/Native.h
@@ -22,27 +22,23 @@
#ifndef _DALVIK_NATIVE
#define _DALVIK_NATIVE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Method description; equivalent to a JNI struct.
*/
-typedef struct DalvikNativeMethod {
+struct DalvikNativeMethod {
const char* name;
const char* signature;
DalvikNativeFunc fnPtr;
-} DalvikNativeMethod;
+};
/*
* All methods for one class. The last "methodInfo" has a NULL "name".
*/
-typedef struct DalvikNativeClass {
+struct DalvikNativeClass {
const char* classDescriptor;
const DalvikNativeMethod* methodInfo;
u4 classDescriptorHash; /* initialized at runtime */
-} DalvikNativeClass;
+};
/* init/shutdown */
@@ -53,8 +49,8 @@
/*
* Convert argc/argv into a function call. This is platform-specific.
*/
-void dvmPlatformInvoke(void* pEnv, ClassObject* clazz, int argInfo, int argc,
- const u4* argv, const char* signature, void* func, JValue* pResult);
+extern "C" void dvmPlatformInvoke(void* pEnv, ClassObject* clazz, int argInfo,
+ int argc, const u4* argv, const char* signature, void* func, JValue* pResult);
/*
* Generate hints to speed native calls. This is platform specific.
@@ -123,8 +119,4 @@
void dvmLogNativeMethodExit(const Method* method, struct Thread* self,
const JValue retval);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_NATIVE*/
diff --git a/vm/PointerSet.h b/vm/PointerSet.h
index 6e43f67..ddc5532 100644
--- a/vm/PointerSet.h
+++ b/vm/PointerSet.h
@@ -20,12 +20,7 @@
#ifndef _DALVIK_POINTERSET
#define _DALVIK_POINTERSET
-#ifdef __cplusplus
-extern "C" {
-#endif
-
struct PointerSet; /* private */
-typedef struct PointerSet PointerSet;
/*
* Allocate a new PointerSet.
@@ -96,8 +91,4 @@
*/
void dvmPointerSetDump(const PointerSet* pSet);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_POINTERSET*/
diff --git a/vm/Profile.h b/vm/Profile.h
index 12063b9..27d7c89 100644
--- a/vm/Profile.h
+++ b/vm/Profile.h
@@ -24,10 +24,6 @@
#include <stdio.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
struct Thread; // extern
@@ -39,7 +35,7 @@
* Method trace state. This is currently global. In theory we could make
* most of this per-thread.
*/
-typedef struct MethodTraceState {
+struct MethodTraceState {
/* active state */
pthread_mutex_t startStopLock;
pthread_cond_t threadExitCond;
@@ -53,7 +49,7 @@
volatile int curOffset;
u8 startWhen;
int overflow;
-} MethodTraceState;
+};
/*
* Memory allocation profiler state. This is used both globally and
@@ -61,7 +57,7 @@
*
* If you add a field here, zero it out in dvmStartAllocCounting().
*/
-typedef struct AllocProfState {
+struct AllocProfState {
bool enabled; // is allocation tracking enabled?
int allocCount; // #of objects allocated
@@ -77,7 +73,7 @@
int classInitCount; // #of initialized classes
u8 classInitTime; // cumulative time spent in class init (nsec)
-} AllocProfState;
+};
/*
@@ -141,9 +137,9 @@
void dvmMethodTraceClassPrepBegin(void);
void dvmMethodTraceClassPrepEnd(void);
-void dvmFastMethodTraceEnter(const Method* method, struct Thread* self);
-void dvmFastMethodTraceExit(struct Thread* self);
-void dvmFastNativeMethodTraceExit(const Method* method, struct Thread* self);
+extern "C" void dvmFastMethodTraceEnter(const Method* method, struct Thread* self);
+extern "C" void dvmFastMethodTraceExit(struct Thread* self);
+extern "C" void dvmFastNativeMethodTraceExit(const Method* method, struct Thread* self);
/*
* Start/stop alloc counting.
@@ -175,8 +171,4 @@
#define METHOD_ACTION(_method) (((unsigned int)(_method)) & METHOD_ACTION_MASK)
#define METHOD_COMBINE(_method, _action) ((_method) | (_action))
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_PROFILE*/
diff --git a/vm/Properties.h b/vm/Properties.h
index 6226d7f..138be41 100644
--- a/vm/Properties.h
+++ b/vm/Properties.h
@@ -19,18 +19,10 @@
#ifndef _DALVIK_PROPERTIES
#define _DALVIK_PROPERTIES
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Initialization.
*/
bool dvmPropertiesStartup(void);
void dvmPropertiesShutdown(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_PROPERTIES*/
diff --git a/vm/RawDexFile.h b/vm/RawDexFile.h
index f2c1b68..ba777bb 100644
--- a/vm/RawDexFile.h
+++ b/vm/RawDexFile.h
@@ -21,18 +21,14 @@
#ifndef _DALVIK_RAWDEXFILE
#define _DALVIK_RAWDEXFILE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Structure representing a "raw" DEX file, in its unswapped unoptimized
* state.
*/
-typedef struct RawDexFile {
+struct RawDexFile {
char* cacheFileName;
DvmDex* pDvmDex;
-} RawDexFile;
+};
/*
* Open a raw ".dex" file, optimize it, and load it.
@@ -72,8 +68,4 @@
return pRawDexFile->cacheFileName;
}
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_RAWDEXFILE*/
diff --git a/vm/ReferenceTable.h b/vm/ReferenceTable.h
index ce7c1f7..db2389f 100644
--- a/vm/ReferenceTable.h
+++ b/vm/ReferenceTable.h
@@ -23,10 +23,6 @@
#ifndef _DALVIK_REFERENCETABLE
#define _DALVIK_REFERENCETABLE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Table definition.
*
@@ -40,13 +36,13 @@
* (This structure is still somewhat transparent; direct access to
* table/nextEntry is allowed.)
*/
-typedef struct ReferenceTable {
+struct ReferenceTable {
Object** nextEntry; /* top of the list */
Object** table; /* bottom of the list */
int allocEntries; /* #of entries we have space for */
int maxEntries; /* max #of entries allowed */
-} ReferenceTable;
+};
/*
* Initialize a ReferenceTable.
@@ -126,8 +122,4 @@
void dvmDumpReferenceTableContents(Object* const* refs, size_t count,
const char* descr);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_REFERENCETABLE*/
diff --git a/vm/SignalCatcher.h b/vm/SignalCatcher.h
index f9e1dd7..ece052c 100644
--- a/vm/SignalCatcher.h
+++ b/vm/SignalCatcher.h
@@ -19,15 +19,7 @@
#ifndef _DALVIK_SIGNALCATCHER
#define _DALVIK_SIGNALCATCHER
-#ifdef __cplusplus
-extern "C" {
-#endif
-
bool dvmSignalCatcherStartup(void);
void dvmSignalCatcherShutdown(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_SIGNALCATCHER*/
diff --git a/vm/StdioConverter.cpp b/vm/StdioConverter.cpp
index 7776688..a98d473 100644
--- a/vm/StdioConverter.cpp
+++ b/vm/StdioConverter.cpp
@@ -30,20 +30,20 @@
/*
* Hold our replacement stdout/stderr.
*/
-typedef struct StdPipes {
+struct StdPipes {
int stdoutPipe[2];
int stderrPipe[2];
-} StdPipes;
+};
#define kMaxLine 512
/*
* Hold some data.
*/
-typedef struct BufferedData {
+struct BufferedData {
char buf[kMaxLine+1];
int count;
-} BufferedData;
+};
// fwd
static void* stdioConverterThreadStart(void* arg);
diff --git a/vm/StdioConverter.h b/vm/StdioConverter.h
index 37384eb..ffbf807 100644
--- a/vm/StdioConverter.h
+++ b/vm/StdioConverter.h
@@ -19,15 +19,7 @@
#ifndef _DALVIK_STDOUTCONVERTER
#define _DALVIK_STDOUTCONVERTER
-#ifdef __cplusplus
-extern "C" {
-#endif
-
bool dvmStdioConverterStartup(void);
void dvmStdioConverterShutdown(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_STDOUTCONVERTER*/
diff --git a/vm/Sync.h b/vm/Sync.h
index 9f4592d..14b34fd 100644
--- a/vm/Sync.h
+++ b/vm/Sync.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_SYNC
#define _DALVIK_SYNC
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Monitor shape field. Used to distinguish immediate thin locks from
* indirecting fat locks.
@@ -70,7 +66,6 @@
struct Object;
struct Monitor;
struct Thread;
-typedef struct Monitor Monitor;
/*
* Returns true if the lock has been fattened.
@@ -80,25 +75,25 @@
/*
* Acquire the object's monitor.
*/
-void dvmLockObject(struct Thread* self, struct Object* obj);
+extern "C" void dvmLockObject(Thread* self, Object* obj);
/* Returns true if the unlock succeeded.
* If the unlock failed, an exception will be pending.
*/
-bool dvmUnlockObject(struct Thread* self, struct Object* obj);
+extern "C" bool dvmUnlockObject(Thread* self, Object* obj);
/*
* Implementations of some java/lang/Object calls.
*/
-void dvmObjectWait(struct Thread* self, struct Object* obj,
+void dvmObjectWait(Thread* self, Object* obj,
s8 timeout, s4 nanos, bool interruptShouldThrow);
-void dvmObjectNotify(struct Thread* self, struct Object* obj);
-void dvmObjectNotifyAll(struct Thread* self, struct Object* obj);
+void dvmObjectNotify(Thread* self, Object* obj);
+void dvmObjectNotifyAll(Thread* self, Object* obj);
/*
* Implementation of System.identityHashCode().
*/
-u4 dvmIdentityHashCode(struct Object* obj);
+u4 dvmIdentityHashCode(Object* obj);
/*
* Implementation of Thread.sleep().
@@ -110,10 +105,10 @@
*
* Interrupt a thread. If it's waiting on a monitor, wake it up.
*/
-void dvmThreadInterrupt(struct Thread* thread);
+void dvmThreadInterrupt(Thread* thread);
/* create a new Monitor struct */
-Monitor* dvmCreateMonitor(struct Object* obj);
+Monitor* dvmCreateMonitor(Object* obj);
/*
* Frees unmarked monitors from the monitor list. The given callback
@@ -131,7 +126,7 @@
* Returns NULL if "mon" is NULL or the monitor is not part of an object
* (which should only happen for Thread.sleep() in the current implementation).
*/
-struct Object* dvmGetMonitorObject(Monitor* mon);
+Object* dvmGetMonitorObject(Monitor* mon);
/*
* Get the thread that holds the lock on the specified object. The
@@ -139,12 +134,12 @@
*
* The caller must lock the thread list before calling here.
*/
-struct Thread* dvmGetObjectLockHolder(struct Object* obj);
+Thread* dvmGetObjectLockHolder(Object* obj);
/*
* Checks whether the object is held by the specified thread.
*/
-bool dvmHoldsLock(struct Thread* thread, struct Object* obj);
+bool dvmHoldsLock(Thread* thread, Object* obj);
/*
* Relative timed wait on condition
@@ -152,8 +147,4 @@
int dvmRelativeCondWait(pthread_cond_t* cond, pthread_mutex_t* mutex,
s8 msec, s4 nsec);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_SYNC*/
diff --git a/vm/Thread.h b/vm/Thread.h
index 440dfe3..2f0a29d 100644
--- a/vm/Thread.h
+++ b/vm/Thread.h
@@ -26,10 +26,6 @@
#include <errno.h>
#include <cutils/sched_policy.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#if defined(CHECK_MUTEX) && !defined(__USE_UNIX98)
/* glibc lacks this unless you #define __USE_UNIX98 */
int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
@@ -43,7 +39,7 @@
*
* Note that "suspended" is orthogonal to these values (so says JDWP).
*/
-typedef enum ThreadStatus {
+enum ThreadStatus {
THREAD_UNDEFINED = -1, /* makes enum compatible with int32_t */
/* these match up with JDWP values */
@@ -58,7 +54,7 @@
THREAD_NATIVE = 7, /* off in a JNI native method */
THREAD_VMWAIT = 8, /* waiting on a VM resource */
THREAD_SUSPENDED = 9, /* suspended, usually by GC or debugger */
-} ThreadStatus;
+};
/* thread priorities, from java.lang.Thread */
enum {
@@ -87,7 +83,7 @@
* Interpreter control struction. Packed into a long long to enable
* atomic updates.
*/
-typedef union InterpBreak {
+union InterpBreak {
volatile int64_t all;
struct {
uint16_t subMode;
@@ -99,14 +95,14 @@
void* unused;
#endif
} ctl;
-} InterpBreak;
+};
/*
* Our per-thread data.
*
* These are allocated on the system heap.
*/
-typedef struct Thread {
+struct Thread {
/*
* Interpreter state which must be preserved across nested
* interpreter invocations (via JNI callbacks). Must be the first
@@ -308,13 +304,13 @@
pthread_mutex_t callbackMutex;
SafePointCallback callback;
void* callbackArg;
-} Thread;
+};
/* start point for an internal thread; mimics pthread args */
typedef void* (*InternalThreadStart)(void* arg);
/* args for internal thread creation */
-typedef struct InternalStartArgs {
+struct InternalStartArgs {
/* inputs */
InternalThreadStart func;
void* funcArg;
@@ -324,7 +320,7 @@
/* result */
volatile Thread** pThread;
volatile int* pCreateStatus;
-} InternalStartArgs;
+};
/* finish init */
bool dvmPrepMainForJni(JNIEnv* pEnv);
@@ -350,7 +346,7 @@
/*
* Thread suspend/resume, used by the GC and debugger.
*/
-typedef enum SuspendCause {
+enum SuspendCause {
SUSPEND_NOT = 0,
SUSPEND_FOR_GC,
SUSPEND_FOR_DEBUG,
@@ -365,7 +361,7 @@
SUSPEND_FOR_CC_RESET, // code-cache reset
SUSPEND_FOR_REFRESH, // Reload data cached in interpState
#endif
-} SuspendCause;
+};
void dvmSuspendThread(Thread* thread);
void dvmSuspendSelf(bool jdwpActivity);
void dvmResumeThread(Thread* thread);
@@ -387,7 +383,7 @@
* Check to see if we should be suspended now. If so, suspend ourselves
* by sleeping on a condition variable.
*/
-bool dvmCheckSuspendPending(Thread* self);
+extern "C" bool dvmCheckSuspendPending(Thread* self);
/*
* Fast test for use in the interpreter. Returns "true" if our suspend
@@ -601,8 +597,4 @@
*/
void dvmNukeThread(Thread* thread);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_THREAD*/
diff --git a/vm/UtfString.h b/vm/UtfString.h
index 6b9a5e3..b577d3a 100644
--- a/vm/UtfString.h
+++ b/vm/UtfString.h
@@ -21,10 +21,6 @@
#ifndef _DALVIK_STRING
#define _DALVIK_STRING
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* (This is private to UtfString.c, but we cheat a bit and also use it
* for InlineNative.c. Not really worth creating a separate header.)
@@ -149,8 +145,4 @@
*/
int dvmHashcmpStrings(const void* vstrObj1, const void* vstrObj2);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_STRING*/
diff --git a/vm/alloc/Copying.cpp b/vm/alloc/Copying.cpp
index a1e503a..47df05f 100644
--- a/vm/alloc/Copying.cpp
+++ b/vm/alloc/Copying.cpp
@@ -527,7 +527,7 @@
*gcHeap = NULL;
}
-size_t dvmHeapSourceGetValue(enum HeapSourceValueSpec spec,
+size_t dvmHeapSourceGetValue(HeapSourceValueSpec spec,
size_t perHeapStats[],
size_t arrayLen)
{
diff --git a/vm/alloc/HeapSource.cpp b/vm/alloc/HeapSource.cpp
index d944560..6666f88 100644
--- a/vm/alloc/HeapSource.cpp
+++ b/vm/alloc/HeapSource.cpp
@@ -652,7 +652,7 @@
* Caller must hold the heap lock.
*/
size_t
-dvmHeapSourceGetValue(enum HeapSourceValueSpec spec, size_t perHeapStats[],
+dvmHeapSourceGetValue(HeapSourceValueSpec spec, size_t perHeapStats[],
size_t arrayLen)
{
HeapSource *hs = gHs;
diff --git a/vm/analysis/CodeVerify.cpp b/vm/analysis/CodeVerify.cpp
index 2bf67d4..931569f 100644
--- a/vm/analysis/CodeVerify.cpp
+++ b/vm/analysis/CodeVerify.cpp
@@ -37,11 +37,11 @@
* we either only need it at branch points (for verification) or GC points
* and branches (for verification + type-precise register analysis).
*/
-typedef enum RegisterTrackingMode {
+enum RegisterTrackingMode {
kTrackRegsBranches,
kTrackRegsGcPoints,
kTrackRegsAll
-} RegisterTrackingMode;
+};
/*
* Set this to enable dead code scanning. This is not required, but it's
@@ -1820,12 +1820,12 @@
* We treat object references separately, so we have "category1nr". We
* don't support jsr/ret, so there is no "returnAddress" type.
*/
-typedef enum TypeCategory {
+enum TypeCategory {
kTypeCategoryUnknown = 0,
kTypeCategory1nr, // boolean, byte, char, short, int, float
kTypeCategory2, // long, double
kTypeCategoryRef, // object reference
-} TypeCategory;
+};
/*
* See if "type" matches "cat". All we're really looking for here is that
diff --git a/vm/analysis/CodeVerify.h b/vm/analysis/CodeVerify.h
index 4fbf700..1eb27b9 100644
--- a/vm/analysis/CodeVerify.h
+++ b/vm/analysis/CodeVerify.h
@@ -23,10 +23,6 @@
#include "analysis/VerifySubs.h"
#include "analysis/VfyBasicBlock.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Enumeration for register type values. The "hi" piece of a 64-bit value
* MUST immediately follow the "lo" piece in the enumeration, so we can check
@@ -129,32 +125,32 @@
* track the liveness of the method result register (which is not visible
* to the GC).
*/
-typedef struct {
+struct RegisterLine {
RegType* regTypes;
MonitorEntries* monitorEntries;
u4* monitorStack;
unsigned int monitorStackTop;
BitVector* liveRegs;
-} RegisterLine;
+};
/*
* Table that maps uninitialized instances to classes, based on the
* address of the new-instance instruction. One per method.
*/
-typedef struct UninitInstanceMap {
+struct UninitInstanceMap {
int numEntries;
struct {
int addr; /* code offset, or -1 for method arg ("this") */
ClassObject* clazz; /* class created at this address */
} map[1];
-} UninitInstanceMap;
+};
#define kUninitThisArgAddr (-1)
#define kUninitThisArgSlot 0
/*
* Various bits of data used by the verifier and register map generator.
*/
-typedef struct VerifierData {
+struct VerifierData {
/*
* The method we're working on.
*/
@@ -203,7 +199,7 @@
* for liveness analysis.
*/
VfyBasicBlock** basicBlocks;
-} VerifierData;
+};
/* table with static merge logic for primitive types */
@@ -325,8 +321,4 @@
*/
bool dvmVerifyCodeFlow(VerifierData* vdata);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_CODEVERIFY*/
diff --git a/vm/analysis/DexPrepare.h b/vm/analysis/DexPrepare.h
index 27668b1..9e43f26 100644
--- a/vm/analysis/DexPrepare.h
+++ b/vm/analysis/DexPrepare.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_DEXPREPARE
#define _DALVIK_DEXPREPARE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Global DEX optimizer control. Determines the circumstances in which we
* try to rewrite instructions in the DEX file.
@@ -31,13 +27,13 @@
* Optimizing is performed ahead-of-time by dexopt and, in some cases, at
* load time by the VM.
*/
-typedef enum DexOptimizerMode {
+enum DexOptimizerMode {
OPTIMIZE_MODE_UNKNOWN = 0,
OPTIMIZE_MODE_NONE, /* never optimize (except "essential") */
OPTIMIZE_MODE_VERIFIED, /* only optimize verified classes (default) */
OPTIMIZE_MODE_ALL, /* optimize verified & unverified (risky) */
OPTIMIZE_MODE_FULL /* fully opt verified classes at load time */
-} DexOptimizerMode;
+};
/* some additional bit flags for dexopt */
enum DexoptFlags {
@@ -54,7 +50,7 @@
/*
* An enumeration of problems that can turn up during verification.
*/
-typedef enum VerifyError {
+enum VerifyError {
VERIFY_ERROR_NONE = 0, /* no error; must be zero */
VERIFY_ERROR_GENERIC, /* VerifyError */
@@ -66,7 +62,7 @@
VERIFY_ERROR_ACCESS_METHOD, /* IllegalAccessError */
VERIFY_ERROR_CLASS_CHANGE, /* IncompatibleClassChangeError */
VERIFY_ERROR_INSTANTIATION, /* InstantiationError */
-} VerifyError;
+};
/*
* Identifies the type of reference in the instruction that generated the
@@ -75,11 +71,11 @@
*
* This must fit in two bits.
*/
-typedef enum VerifyErrorRefType {
+enum VerifyErrorRefType {
VERIFY_ERROR_REF_CLASS = 0,
VERIFY_ERROR_REF_FIELD = 1,
VERIFY_ERROR_REF_METHOD = 2,
-} VerifyErrorRefType;
+};
#define kVerifyErrorRefTypeShift 6
@@ -138,8 +134,4 @@
bool dvmCreateInlineSubsTable(void);
void dvmFreeInlineSubsTable(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_DEXPREPARE*/
diff --git a/vm/analysis/DexVerify.h b/vm/analysis/DexVerify.h
index a990502..d98cee9 100644
--- a/vm/analysis/DexVerify.h
+++ b/vm/analysis/DexVerify.h
@@ -20,21 +20,30 @@
#ifndef _DALVIK_DEXVERIFY
#define _DALVIK_DEXVERIFY
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Global verification mode. These must be in order from least verification
* to most. If we're using "exact GC", we may need to perform some of
* the verification steps anyway.
*/
-typedef enum {
+enum DexClassVerifyMode {
VERIFY_MODE_UNKNOWN = 0,
VERIFY_MODE_NONE,
VERIFY_MODE_REMOTE,
VERIFY_MODE_ALL
-} DexClassVerifyMode;
+};
+
+/* some verifier counters, for debugging */
+struct VerifierStats {
+ size_t methodsExamined; /* number of methods examined */
+ size_t monEnterMethods; /* number of methods with monitor-enter */
+ size_t instrsExamined; /* incr on first visit of instruction */
+ size_t instrsReexamined; /* incr on each repeat visit of instruction */
+ size_t copyRegCount; /* calls from updateRegisters->copyRegisters */
+ size_t mergeRegCount; /* calls from updateRegisters->merge */
+ size_t mergeRegChanged; /* calls from updateRegisters->merge, changed */
+ size_t uninitSearches; /* times we've had to search the uninit table */
+ size_t biggestAlloc; /* largest RegisterLine table alloc */
+};
/*
* Certain types of instructions can be GC points. To support precise
@@ -54,21 +63,4 @@
*/
void dvmFreeRegisterMap(RegisterMap* pMap);
-/* some verifier counters, for debugging */
-typedef struct {
- size_t methodsExamined; /* number of methods examined */
- size_t monEnterMethods; /* number of methods with monitor-enter */
- size_t instrsExamined; /* incr on first visit of instruction */
- size_t instrsReexamined; /* incr on each repeat visit of instruction */
- size_t copyRegCount; /* calls from updateRegisters->copyRegisters */
- size_t mergeRegCount; /* calls from updateRegisters->merge */
- size_t mergeRegChanged; /* calls from updateRegisters->merge, changed */
- size_t uninitSearches; /* times we've had to search the uninit table */
- size_t biggestAlloc; /* largest RegisterLine table alloc */
-} VerifierStats;
-
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_DEXVERIFY*/
diff --git a/vm/analysis/Liveness.h b/vm/analysis/Liveness.h
index d9ca9cf..6436f66 100644
--- a/vm/analysis/Liveness.h
+++ b/vm/analysis/Liveness.h
@@ -20,16 +20,8 @@
#ifndef _DALVIK_LIVENESS
#define _DALVIK_LIVENESS
-#ifdef __cplusplus
-extern "C" {
-#endif
-
struct VerifierData;
bool dvmComputeLiveness(struct VerifierData* vdata);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_LIVENESS*/
diff --git a/vm/analysis/Optimize.h b/vm/analysis/Optimize.h
index 9383881..75b6eab 100644
--- a/vm/analysis/Optimize.h
+++ b/vm/analysis/Optimize.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_OPTIMIZE
#define _DALVIK_OPTIMIZE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Entry point from DEX preparation.
*/
@@ -48,8 +44,4 @@
StaticField* dvmOptResolveStaticField(ClassObject* referrer, u4 sfieldIdx,
VerifyError* pFailure);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OPTIMIZE*/
diff --git a/vm/analysis/RegisterMap.cpp b/vm/analysis/RegisterMap.cpp
index 54b5768..37b2116 100644
--- a/vm/analysis/RegisterMap.cpp
+++ b/vm/analysis/RegisterMap.cpp
@@ -58,7 +58,7 @@
#define kUpdatePosnMinRegs 24
#define kNumUpdatePosns 8
#define kMaxDiffBits 20
-typedef struct MapStats {
+struct MapStats {
/*
* Buckets measuring the distance between GC points. This tells us how
* many bits we need to encode the advancing program counter. We ignore
@@ -103,7 +103,7 @@
*/
int numExpandedMaps;
int totalExpandedMapSize;
-} MapStats;
+};
#endif
/*
diff --git a/vm/analysis/RegisterMap.h b/vm/analysis/RegisterMap.h
index becb1de..2f34c39 100644
--- a/vm/analysis/RegisterMap.h
+++ b/vm/analysis/RegisterMap.h
@@ -25,14 +25,10 @@
#include "analysis/VerifySubs.h"
#include "analysis/CodeVerify.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Format enumeration for RegisterMap data area.
*/
-typedef enum RegisterMapFormat {
+enum RegisterMapFormat {
kRegMapFormatUnknown = 0,
kRegMapFormatNone, /* indicates no map data follows */
kRegMapFormatCompact8, /* compact layout, 8-bit addresses */
@@ -40,7 +36,7 @@
kRegMapFormatDifferential, /* compressed, differential encoding */
kRegMapFormatOnHeap = 0x80, /* bit flag, indicates allocation on heap */
-} RegisterMapFormat;
+};
/*
* This is a single variable-size structure. It may be allocated on the
@@ -163,12 +159,12 @@
*
* These structures are 32-bit aligned.
*/
-typedef struct RegisterMapMethodPool {
+struct RegisterMapMethodPool {
u2 methodCount; /* chiefly used as a sanity check */
/* stream of per-method data starts here */
u4 methodData[1];
-} RegisterMapMethodPool;
+};
/*
* Header for the memory-mapped RegisterMap pool in the DEX file.
@@ -181,12 +177,12 @@
*
* These structures are 32-bit aligned.
*/
-typedef struct RegisterMapClassPool {
+struct RegisterMapClassPool {
u4 numClasses;
/* offset table starts here, 32-bit aligned; offset==0 means no data */
u4 classDataOffset[1];
-} RegisterMapClassPool;
+};
/*
* Find the register maps for this class. (Used during class loading.)
@@ -213,14 +209,14 @@
* In particular, it keeps track of our temporary mmap region so we can
* free it later.
*/
-typedef struct RegisterMapBuilder {
+struct RegisterMapBuilder {
/* public */
void* data;
size_t size;
/* private */
MemMapping memMap;
-} RegisterMapBuilder;
+};
/*
* Generate a register map set for all verified classes in "pDvmDex".
@@ -267,8 +263,4 @@
/* dump stats gathered during register map creation process */
void dvmRegisterMapDumpStats(void);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_REGISTERMAP*/
diff --git a/vm/analysis/VerifySubs.h b/vm/analysis/VerifySubs.h
index 452355b..625244d 100644
--- a/vm/analysis/VerifySubs.h
+++ b/vm/analysis/VerifySubs.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_VERIFYSUBS
#define _DALVIK_VERIFYSUBS
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* InsnFlags is a 32-bit integer with the following layout:
* 0-15 instruction length (or 0 if this address doesn't hold an opcode)
@@ -75,8 +71,4 @@
/* debugging */
bool dvmWantVerboseVerification(const Method* meth);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_VERIFYSUBS*/
diff --git a/vm/analysis/VfyBasicBlock.h b/vm/analysis/VfyBasicBlock.h
index f14953e..6d1d76f 100644
--- a/vm/analysis/VfyBasicBlock.h
+++ b/vm/analysis/VfyBasicBlock.h
@@ -23,10 +23,6 @@
#include "PointerSet.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
struct VerifierData;
@@ -43,14 +39,14 @@
* the RegisterLine for the last instruction in the block (which reflects
* the state *before* the instruction has executed).
*/
-typedef struct {
+struct VfyBasicBlock {
u4 firstAddr; /* address of first instruction */
u4 lastAddr; /* address of last instruction */
PointerSet* predecessors; /* set of basic blocks that can flow here */
BitVector* liveRegs; /* liveness for each register */
bool changed; /* input set has changed, must re-eval */
bool visited; /* block has been visited at least once */
-} VfyBasicBlock;
+};
/*
* Generate a list of basic blocks.
@@ -62,8 +58,4 @@
*/
void dvmFreeVfyBasicBlocks(struct VerifierData* vdata);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_VFYBASICBLOCK*/
diff --git a/vm/compiler/Compiler.h b/vm/compiler/Compiler.h
index 3ceb447..2cf2935 100644
--- a/vm/compiler/Compiler.h
+++ b/vm/compiler/Compiler.h
@@ -20,10 +20,6 @@
#include <setjmp.h>
#include "Thread.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Uncomment the following to enable JIT signature breakpoint
* #define SIGNATURE_BREAKPOINT
@@ -241,13 +237,9 @@
void dvmCompilerUpdateGlobalState(void);
JitTraceDescription *dvmCopyTraceDescriptor(const u2 *pc,
const struct JitEntry *desc);
-void *dvmCompilerGetInterpretTemplate();
+extern "C" void *dvmCompilerGetInterpretTemplate();
JitInstructionSetType dvmCompilerGetInterpretTemplateSet();
u8 dvmGetRegResourceMask(int reg);
void dvmDumpCFG(struct CompilationUnit *cUnit, const char *dirPrefix);
-#ifdef __cplusplus
-}
-#endif
-
#endif /* _DALVIK_VM_COMPILER */
diff --git a/vm/compiler/codegen/CompilerCodegen.h b/vm/compiler/codegen/CompilerCodegen.h
index 8223d2a..2e3b107 100644
--- a/vm/compiler/codegen/CompilerCodegen.h
+++ b/vm/compiler/codegen/CompilerCodegen.h
@@ -19,10 +19,6 @@
#include "compiler/CompilerIR.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* Maximal number of switch cases to have inline chains */
#define MAX_CHAINED_SWITCH_CASES 64
@@ -39,7 +35,7 @@
void dvmCompilerAssembleLIR(CompilationUnit *cUnit, JitTranslationInfo *info);
/* Perform translation chain operation. */
-void* dvmJitChain(void* tgtAddr, u4* branchAddr);
+extern "C" void* dvmJitChain(void* tgtAddr, u4* branchAddr);
/* Install class objects in the literal pool */
void dvmJitInstallClassObjectPointers(CompilationUnit *cUnit,
@@ -75,8 +71,4 @@
/* Implemented in codegen/<target>/<target_variant>/ArchVariant.c */
void dvmCompilerGenMemBarrier(CompilationUnit *cUnit, int barrierKind);
-#ifdef __cplusplus
-}
-#endif
-
#endif /* _DALVIK_VM_COMPILERCODEGEN_H_ */
diff --git a/vm/compiler/codegen/Optimizer.h b/vm/compiler/codegen/Optimizer.h
index 2b05476..dd8e788 100644
--- a/vm/compiler/codegen/Optimizer.h
+++ b/vm/compiler/codegen/Optimizer.h
@@ -23,14 +23,14 @@
* If the corresponding bit is set in gDvmJit.disableOpt, the selected
* optimization will be suppressed.
*/
-typedef enum optControlVector {
+enum optControlVector {
kLoadStoreElimination = 0,
kLoadHoisting,
kTrackLiveTemps,
kSuppressLoads,
kMethodInlining,
kMethodJit,
-} optControlVector;
+};
/* Forward declarations */
struct CompilationUnit;
diff --git a/vm/compiler/codegen/arm/CalloutHelper.h b/vm/compiler/codegen/arm/CalloutHelper.h
index 3bfb299..2660108 100644
--- a/vm/compiler/codegen/arm/CalloutHelper.h
+++ b/vm/compiler/codegen/arm/CalloutHelper.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_VM_COMPILER_CODEGEN_ARM_CALLOUT_HELPER_H
#define _DALVIK_VM_COMPILER_CODEGEN_ARM_CALLOUT_HELPER_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Declare/comment prototypes of all native callout functions invoked by the
* JIT'ed code here and use the LOAD_FUNC_ADDR macro to load the address into
@@ -35,37 +31,37 @@
#define LOAD_FUNC_ADDR(cUnit, reg, addr) loadConstant(cUnit, reg, addr)
/* Conversions */
-float __aeabi_i2f(int op1); // OP_INT_TO_FLOAT
-int __aeabi_f2iz(float op1); // OP_FLOAT_TO_INT
-float __aeabi_d2f(double op1); // OP_DOUBLE_TO_FLOAT
-double __aeabi_f2d(float op1); // OP_FLOAT_TO_DOUBLE
-double __aeabi_i2d(int op1); // OP_INT_TO_DOUBLE
-int __aeabi_d2iz(double op1); // OP_DOUBLE_TO_INT
-float __aeabi_l2f(long op1); // OP_LONG_TO_FLOAT
-double __aeabi_l2d(long op1); // OP_LONG_TO_DOUBLE
+extern "C" float __aeabi_i2f(int op1); // OP_INT_TO_FLOAT
+extern "C" int __aeabi_f2iz(float op1); // OP_FLOAT_TO_INT
+extern "C" float __aeabi_d2f(double op1); // OP_DOUBLE_TO_FLOAT
+extern "C" double __aeabi_f2d(float op1); // OP_FLOAT_TO_DOUBLE
+extern "C" double __aeabi_i2d(int op1); // OP_INT_TO_DOUBLE
+extern "C" int __aeabi_d2iz(double op1); // OP_DOUBLE_TO_INT
+extern "C" float __aeabi_l2f(long op1); // OP_LONG_TO_FLOAT
+extern "C" double __aeabi_l2d(long op1); // OP_LONG_TO_DOUBLE
s8 dvmJitf2l(float op1); // OP_FLOAT_TO_LONG
s8 dvmJitd2l(double op1); // OP_DOUBLE_TO_LONG
/* Single-precision FP arithmetics */
-float __aeabi_fadd(float a, float b); // OP_ADD_FLOAT[_2ADDR]
-float __aeabi_fsub(float a, float b); // OP_SUB_FLOAT[_2ADDR]
-float __aeabi_fdiv(float a, float b); // OP_DIV_FLOAT[_2ADDR]
-float __aeabi_fmul(float a, float b); // OP_MUL_FLOAT[_2ADDR]
-float fmodf(float a, float b); // OP_REM_FLOAT[_2ADDR]
+extern "C" float __aeabi_fadd(float a, float b); // OP_ADD_FLOAT[_2ADDR]
+extern "C" float __aeabi_fsub(float a, float b); // OP_SUB_FLOAT[_2ADDR]
+extern "C" float __aeabi_fdiv(float a, float b); // OP_DIV_FLOAT[_2ADDR]
+extern "C" float __aeabi_fmul(float a, float b); // OP_MUL_FLOAT[_2ADDR]
+extern "C" float fmodf(float a, float b); // OP_REM_FLOAT[_2ADDR]
/* Double-precision FP arithmetics */
-double __aeabi_dadd(double a, double b); // OP_ADD_DOUBLE[_2ADDR]
-double __aeabi_dsub(double a, double b); // OP_SUB_DOUBLE[_2ADDR]
-double __aeabi_ddiv(double a, double b); // OP_DIV_DOUBLE[_2ADDR]
-double __aeabi_dmul(double a, double b); // OP_MUL_DOUBLE[_2ADDR]
-double fmod(double a, double b); // OP_REM_DOUBLE[_2ADDR]
+extern "C" double __aeabi_dadd(double a, double b); // OP_ADD_DOUBLE[_2ADDR]
+extern "C" double __aeabi_dsub(double a, double b); // OP_SUB_DOUBLE[_2ADDR]
+extern "C" double __aeabi_ddiv(double a, double b); // OP_DIV_DOUBLE[_2ADDR]
+extern "C" double __aeabi_dmul(double a, double b); // OP_MUL_DOUBLE[_2ADDR]
+extern "C" double fmod(double a, double b); // OP_REM_DOUBLE[_2ADDR]
/* Integer arithmetics */
-int __aeabi_idivmod(int op1, int op2); // OP_REM_INT[_2ADDR|_LIT8|_LIT16]
-int __aeabi_idiv(int op1, int op2); // OP_DIV_INT[_2ADDR|_LIT8|_LIT16]
+extern "C" int __aeabi_idivmod(int op1, int op2); // OP_REM_INT[_2ADDR|_LIT8|_LIT16]
+extern "C" int __aeabi_idiv(int op1, int op2); // OP_DIV_INT[_2ADDR|_LIT8|_LIT16]
/* Long long arithmetics - OP_REM_LONG[_2ADDR] & OP_DIV_LONG[_2ADDR] */
-long long __aeabi_ldivmod(long long op1, long long op2);
+extern "C" long long __aeabi_ldivmod(long long op1, long long op2);
/* Originally declared in Sync.h */
bool dvmUnlockObject(struct Thread* self, struct Object* obj); //OP_MONITOR_EXIT
@@ -114,7 +110,7 @@
* Functions declared in gDvmInlineOpsTable[] are used for
* OP_EXECUTE_INLINE & OP_EXECUTE_INLINE_RANGE.
*/
-double sqrt(double x); // INLINE_MATH_SQRT
+extern "C" double sqrt(double x); // INLINE_MATH_SQRT
/*
* The following functions are invoked through the compiler templates (declared
@@ -125,8 +121,4 @@
* dvmLockObject // MONITOR_ENTER
*/
-#ifdef __cplusplus
-}
-#endif
-
#endif /* _DALVIK_VM_COMPILER_CODEGEN_ARM_CALLOUT_HELPER_H */
diff --git a/vm/compiler/codegen/arm/Codegen.h b/vm/compiler/codegen/arm/Codegen.h
index afeb340..e67f3d8 100644
--- a/vm/compiler/codegen/arm/Codegen.h
+++ b/vm/compiler/codegen/arm/Codegen.h
@@ -25,10 +25,6 @@
#include "compiler/CompilerIR.h"
#include "CalloutHelper.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#if defined(_CODEGEN_C)
/*
* loadConstant() sometimes needs to add a small imm to a pre-existing constant
@@ -60,14 +56,10 @@
#if defined(WITH_SELF_VERIFICATION)
/* Self Verification memory instruction decoder */
-void dvmSelfVerificationMemOpDecode(int lr, int* sp);
+extern "C" void dvmSelfVerificationMemOpDecode(int lr, int* sp);
#endif
extern void dvmCompilerSetupResourceMasks(ArmLIR *lir);
extern ArmLIR* dvmCompilerRegCopyNoInsert(CompilationUnit *cUnit, int rDest,
int rSrc);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.h b/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.h
index fa01210..452f2a5 100644
--- a/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.h
+++ b/vm/compiler/codegen/arm/armv5te-vfp/ArchVariant.h
@@ -19,7 +19,7 @@
/* Create the TemplateOpcode enum */
#define JIT_TEMPLATE(X) TEMPLATE_##X,
-typedef enum {
+enum TemplateOpcode {
#include "../../../template/armv5te-vfp/TemplateOpList.h"
/*
* For example,
@@ -28,7 +28,7 @@
* ...
*/
TEMPLATE_LAST_MARK,
-} TemplateOpcode;
+};
#undef JIT_TEMPLATE
#endif /* _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV5TE_VFP_ARCHVARIANT_H */
diff --git a/vm/compiler/codegen/arm/armv5te/ArchVariant.h b/vm/compiler/codegen/arm/armv5te/ArchVariant.h
index 4cc4fa6..07a1c8c 100644
--- a/vm/compiler/codegen/arm/armv5te/ArchVariant.h
+++ b/vm/compiler/codegen/arm/armv5te/ArchVariant.h
@@ -19,7 +19,7 @@
/* Create the TemplateOpcode enum */
#define JIT_TEMPLATE(X) TEMPLATE_##X,
-typedef enum {
+enum TemplateOpcode {
#include "../../../template/armv5te/TemplateOpList.h"
/*
* For example,
@@ -28,7 +28,7 @@
* ...
*/
TEMPLATE_LAST_MARK,
-} TemplateOpcode;
+};
#undef JIT_TEMPLATE
#endif /* _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV5TE_ARCHVARIANT_H */
diff --git a/vm/compiler/codegen/arm/armv7-a/ArchVariant.h b/vm/compiler/codegen/arm/armv7-a/ArchVariant.h
index 747ecc1..66e236b 100644
--- a/vm/compiler/codegen/arm/armv7-a/ArchVariant.h
+++ b/vm/compiler/codegen/arm/armv7-a/ArchVariant.h
@@ -14,16 +14,12 @@
* limitations under the License.
*/
-#ifndef _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV5TE_VFP_ARCHVARIANT_H
-#define _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV5TE_VFP_ARCHVARIANT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV7_A_ARCHVARIANT_H
+#define _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV7_A_ARCHVARIANT_H
/* Create the TemplateOpcode enum */
#define JIT_TEMPLATE(X) TEMPLATE_##X,
-typedef enum {
+enum TemplateOpcode {
#include "../../../template/armv5te-vfp/TemplateOpList.h"
/*
* For example,
@@ -32,11 +28,7 @@
* ...
*/
TEMPLATE_LAST_MARK,
-} TemplateOpcode;
+};
#undef JIT_TEMPLATE
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV5TE_VFP_ARCHVARIANT_H */
+#endif /* _DALVIK_VM_COMPILER_CODEGEN_ARM_ARMV7_A_ARCHVARIANT_H */
diff --git a/vm/compiler/codegen/x86/CalloutHelper.h b/vm/compiler/codegen/x86/CalloutHelper.h
index a64f017..52c030f 100644
--- a/vm/compiler/codegen/x86/CalloutHelper.h
+++ b/vm/compiler/codegen/x86/CalloutHelper.h
@@ -54,6 +54,6 @@
* Functions declared in gDvmInlineOpsTable[] are used for
* OP_EXECUTE_INLINE & OP_EXECUTE_INLINE_RANGE.
*/
-double sqrt(double x); // INLINE_MATH_SQRT
+extern "C" double sqrt(double x); // INLINE_MATH_SQRT
#endif /* _DALVIK_VM_COMPILER_CODEGEN_X86_CALLOUT_HELPER_H */
diff --git a/vm/compiler/codegen/x86/ia32/ArchVariant.h b/vm/compiler/codegen/x86/ia32/ArchVariant.h
index e4eebf3..c5ce38e 100644
--- a/vm/compiler/codegen/x86/ia32/ArchVariant.h
+++ b/vm/compiler/codegen/x86/ia32/ArchVariant.h
@@ -19,7 +19,7 @@
/* Create the TemplateOpcode enum */
#define JIT_TEMPLATE(X) TEMPLATE_##X,
-typedef enum {
+enum TemplateOpcode {
#include "../../../template/ia32/TemplateOpList.h"
/*
* For example,
@@ -28,7 +28,7 @@
* ...
*/
TEMPLATE_LAST_MARK,
-} TemplateOpcode;
+};
#undef JIT_TEMPLATE
#endif /* _DALVIK_VM_COMPILER_CODEGEN_X86_IA32_ARCHVARIANT_H */
diff --git a/vm/hprof/Hprof.h b/vm/hprof/Hprof.h
index 1721a6e..e31ccc3 100644
--- a/vm/hprof/Hprof.h
+++ b/vm/hprof/Hprof.h
@@ -18,10 +18,6 @@
#include "Dalvik.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#define HPROF_ID_SIZE (sizeof (u4))
#define UNIQUE_ERROR() \
@@ -36,7 +32,7 @@
typedef hprof_id hprof_object_id;
typedef hprof_id hprof_class_object_id;
-typedef enum hprof_basic_type {
+enum hprof_basic_type {
hprof_basic_object = 2,
hprof_basic_boolean = 4,
hprof_basic_char = 5,
@@ -46,9 +42,9 @@
hprof_basic_short = 9,
hprof_basic_int = 10,
hprof_basic_long = 11,
-} hprof_basic_type;
+};
-typedef enum hprof_tag_t {
+enum hprof_tag_t {
HPROF_TAG_STRING = 0x01,
HPROF_TAG_LOAD_CLASS = 0x02,
HPROF_TAG_UNLOAD_CLASS = 0x03,
@@ -63,13 +59,13 @@
HPROF_TAG_HEAP_DUMP_END = 0x2C,
HPROF_TAG_CPU_SAMPLES = 0x0D,
HPROF_TAG_CONTROL_SETTINGS = 0x0E,
-} hprof_tag_t;
+};
/* Values for the first byte of
* HEAP_DUMP and HEAP_DUMP_SEGMENT
* records:
*/
-typedef enum hprof_heap_tag_t {
+enum hprof_heap_tag_t {
/* standard */
HPROF_ROOT_UNKNOWN = 0xFF,
HPROF_ROOT_JNI_GLOBAL = 0x01,
@@ -95,7 +91,7 @@
HPROF_ROOT_JNI_MONITOR = 0x8e,
HPROF_UNREACHABLE = 0x90, /* obsolete */
HPROF_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3,
-} hprof_heap_tag_t;
+};
/* Represents a top-level hprof record, whose serialized
* format is:
@@ -106,22 +102,22 @@
* and belong to this record
* [u1]* BODY: as many bytes as specified in the above u4 field
*/
-typedef struct hprof_record_t {
+struct hprof_record_t {
unsigned char *body;
u4 time;
u4 length;
size_t allocLen;
u1 tag;
bool dirty;
-} hprof_record_t;
+};
-typedef enum {
+enum HprofHeapId {
HPROF_HEAP_DEFAULT = 0,
HPROF_HEAP_ZYGOTE = 'Z',
HPROF_HEAP_APP = 'A'
-} HprofHeapId;
+};
-typedef struct hprof_context_t {
+struct hprof_context_t {
/* curRec *must* be first so that we
* can cast from a context to a record.
*/
@@ -144,7 +140,7 @@
size_t fileDataSize; // for open_memstream
FILE *memFp;
int fd;
-} hprof_context_t;
+};
/*
@@ -228,8 +224,4 @@
void hprofFreeContext(hprof_context_t *ctx);
int hprofDumpHeap(const char* fileName, int fd, bool directToDdms);
-#ifdef __cplusplus
-}
-#endif
-
#endif // _DALVIK_HPROF_HPROF
diff --git a/vm/interp/Interp.cpp b/vm/interp/Interp.cpp
index c219f36..f61f7ba 100644
--- a/vm/interp/Interp.cpp
+++ b/vm/interp/Interp.cpp
@@ -79,12 +79,12 @@
* The debugger may ask us to create the same breakpoint multiple times.
* We only remove the breakpoint when the last instance is cleared.
*/
-typedef struct {
+struct Breakpoint {
Method* method; /* method we're associated with */
u2* addr; /* absolute memory address */
u1 originalOpcode; /* original 8-bit opcode value */
int setCount; /* #of times this breakpoint was set */
-} Breakpoint;
+};
/*
* Set of breakpoints.
diff --git a/vm/interp/Interp.h b/vm/interp/Interp.h
index f0f2198..0667a2e 100644
--- a/vm/interp/Interp.h
+++ b/vm/interp/Interp.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_INTERP_INTERP
#define _DALVIK_INTERP_INTERP
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Stash the dalvik PC in the frame. Called during interpretation.
*/
@@ -50,7 +46,8 @@
* This is called from the handler for the throw-verification-error
* instruction. "method" is the method currently being executed.
*/
-void dvmThrowVerificationError(const Method* method, int kind, int ref);
+extern "C" void dvmThrowVerificationError(const Method* method,
+ int kind, int ref);
/*
* One-time initialization and shutdown.
@@ -71,7 +68,7 @@
/*
* Recover the opcode that was replaced by a breakpoint.
*/
-u1 dvmGetOriginalOpcode(const u2* addr);
+extern "C" u1 dvmGetOriginalOpcode(const u2* addr);
/*
* Flush any breakpoints associated with methods in "clazz".
@@ -81,18 +78,18 @@
/*
* Debugger support
*/
-void dvmCheckBefore(const u2 *dPC, u4 *fp, Thread* self);
-void dvmReportExceptionThrow(Thread* self, Object* exception);
-void dvmReportPreNativeInvoke(const Method* methodToCall, Thread* self, u4* fp);
-void dvmReportPostNativeInvoke(const Method* methodToCall, Thread* self, u4* fp);
-void dvmReportInvoke(Thread* self, const Method* methodToCall);
-void dvmReportReturn(Thread* self);
+extern "C" void dvmCheckBefore(const u2 *dPC, u4 *fp, Thread* self);
+extern "C" void dvmReportExceptionThrow(Thread* self, Object* exception);
+extern "C" void dvmReportPreNativeInvoke(const Method* methodToCall, Thread* self, u4* fp);
+extern "C" void dvmReportPostNativeInvoke(const Method* methodToCall, Thread* self, u4* fp);
+extern "C" void dvmReportInvoke(Thread* self, const Method* methodToCall);
+extern "C" void dvmReportReturn(Thread* self);
/*
* InterpBreak & subMode control
*/
void dvmDisableSubMode(Thread* thread, ExecutionSubModes subMode);
-void dvmEnableSubMode(Thread* thread, ExecutionSubModes subMode);
+extern "C" void dvmEnableSubMode(Thread* thread, ExecutionSubModes subMode);
void dvmDisableAllSubMode(ExecutionSubModes subMode);
void dvmEnableAllSubMode(ExecutionSubModes subMode);
void dvmAddToSuspendCounts(Thread* thread, int delta, int dbgDelta);
@@ -118,8 +115,4 @@
extern void* dvmAsmAltInstructionStart[];
#endif
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INTERP_INTERP*/
diff --git a/vm/interp/InterpDefs.h b/vm/interp/InterpDefs.h
index c2f4295..f362442 100644
--- a/vm/interp/InterpDefs.h
+++ b/vm/interp/InterpDefs.h
@@ -24,10 +24,6 @@
#ifndef _DALVIK_INTERP_DEFS
#define _DALVIK_INTERP_DEFS
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#if defined(WITH_JIT)
/*
* Size of save area for callee-save FP regs, which are not automatically
@@ -63,13 +59,13 @@
/*
* Process switch statement.
*/
-s4 dvmInterpHandlePackedSwitch(const u2* switchData, s4 testVal);
-s4 dvmInterpHandleSparseSwitch(const u2* switchData, s4 testVal);
+extern "C" s4 dvmInterpHandlePackedSwitch(const u2* switchData, s4 testVal);
+extern "C" s4 dvmInterpHandleSparseSwitch(const u2* switchData, s4 testVal);
/*
* Process fill-array-data.
*/
-bool dvmInterpHandleFillArrayData(ArrayObject* arrayObject,
+extern "C" bool dvmInterpHandleFillArrayData(ArrayObject* arrayObject,
const u2* arrayData);
/*
@@ -109,8 +105,4 @@
#endif
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INTERP_DEFS*/
diff --git a/vm/interp/InterpState.h b/vm/interp/InterpState.h
index d50967d..3795bf9 100644
--- a/vm/interp/InterpState.h
+++ b/vm/interp/InterpState.h
@@ -24,21 +24,17 @@
#ifndef _DALVIK_INTERP_STATE
#define _DALVIK_INTERP_STATE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Execution mode, e.g. interpreter vs. JIT.
*/
-typedef enum ExecutionMode {
+enum ExecutionMode {
kExecutionModeUnknown = 0,
kExecutionModeInterpPortable,
kExecutionModeInterpFast,
#if defined(WITH_JIT)
kExecutionModeJit,
#endif
-} ExecutionMode;
+};
/*
* Execution sub modes, e.g. debugging, profiling, etc.
@@ -46,7 +42,7 @@
* by assembly code in the mterp interpeter and may also be used by
* code generated by the JIT. Take care when changing.
*/
-typedef enum ExecutionSubModes {
+enum ExecutionSubModes {
kSubModeNormal = 0x0000, /* No active subMode */
kSubModeMethodTrace = 0x0001,
kSubModeEmulatorTrace = 0x0002,
@@ -61,7 +57,7 @@
kSubModeEmulatorTrace |
kSubModeInstCounting |
kSubModeDebuggerActive)
-} ExecutionSubModes;
+};
/*
* Interpreter break flags. When set, causes the interpreter to
@@ -69,11 +65,11 @@
* handler.
*/
-typedef enum InterpBreakFlags {
+enum InterpBreakFlags {
kInterpNoBreak = 0x00, /* Don't check */
kInterpSingleStep = 0x01, /* Check between each inst */
kInterpSafePoint = 0x02, /* Check at safe points */
-} InterpBreakFlags;
+};
/*
* Mapping between subModes and required check intervals. Note: in
@@ -96,7 +92,7 @@
*/
#define LOCAL_SUBMODE (kSubModeJitTraceBuild)
-typedef struct InterpSaveState {
+struct InterpSaveState {
const u2* pc; // Dalvik PC
u4* curFrame; // Dalvik frame pointer
const Method *method; // Method being executed
@@ -108,7 +104,7 @@
int unused; // Keep struct size constant
#endif
struct InterpSaveState* prev; // To follow nested activations
-} InterpSaveState;
+};
#ifdef WITH_JIT
/*
@@ -150,7 +146,7 @@
};
/* States of the interpreter when serving a JIT-related request */
-typedef enum JitState {
+enum JitState {
/* Entering states in the debug interpreter */
kJitNot = 0, // Non-JIT related reasons */
kJitTSelectRequest = 1, // Request a trace (subject to filtering)
@@ -161,10 +157,10 @@
kJitTSelect = 4, // Actively selecting a trace
kJitTSelectEnd = 5, // Done with the trace - wrap it up
kJitDone = 6, // No further JIT actions for interpBreak
-} JitState;
+};
#if defined(WITH_SELF_VERIFICATION)
-typedef enum SelfVerificationState {
+enum SelfVerificationState {
kSVSIdle = 0, // Idle
kSVSStart = 1, // Shadow space set up, running compiled code
kSVSPunt = 2, // Exiting compiled code by punting
@@ -175,7 +171,7 @@
kSVSNoChain = 7, // Exiting compiled code by no chain
kSVSBackwardBranch = 8, // Exiting compiled code with backward branch trace
kSVSDebugInterp = 9, // Normal state restored, running debug interpreter
-} SelfVerificationState;
+};
#endif
/* Number of entries in the 2nd level JIT profiler filter cache */
@@ -184,23 +180,23 @@
#define JIT_TRACE_THRESH_FILTER_PC_BITS 4
#define MAX_JIT_RUN_LEN 64
-typedef enum JitHint {
+enum JitHint {
kJitHintNone = 0,
kJitHintTaken = 1, // Last inst in run was taken branch
kJitHintNotTaken = 2, // Last inst in run was not taken branch
kJitHintNoBias = 3, // Last inst in run was unbiased branch
-} jitHint;
+};
/*
* Element of a Jit trace description. If the isCode bit is set, it describes
* a contiguous sequence of Dalvik byte codes.
*/
-typedef struct {
+struct JitCodeDesc {
unsigned numInsts:8; // Number of Byte codes in run
unsigned runEnd:1; // Run ends with last byte code
- jitHint hint:7; // Hint to apply to final code of run
- u2 startOffset; // Starting offset for trace run
-} JitCodeDesc;
+ JitHint hint:7; // Hint to apply to final code of run
+ u2 startOffset; // Starting offset for trace run
+};
/*
* A complete list of trace runs passed to the compiler looks like the
@@ -224,19 +220,15 @@
* descriptor/loader of "this" and the currently resolved method pointer are
* three instances of meta information stored there.
*/
-typedef struct {
+struct JitTraceRun {
union {
JitCodeDesc frag;
void* meta;
} info;
u4 isCode:1;
u4 unused:31;
-} JitTraceRun;
+};
#endif
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INTERP_STATE*/
diff --git a/vm/interp/Jit.h b/vm/interp/Jit.h
index c05fadd..89256ca 100644
--- a/vm/interp/Jit.h
+++ b/vm/interp/Jit.h
@@ -22,10 +22,6 @@
#include "InterpDefs.h"
#include "mterp/common/jit-config.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
#define JIT_MAX_TRACE_LEN 100
#if defined (WITH_SELF_VERIFICATION)
@@ -33,17 +29,17 @@
#define REG_SPACE 256 /* default size of shadow space */
#define HEAP_SPACE JIT_MAX_TRACE_LEN /* default size of heap space */
-typedef struct ShadowHeap {
+struct ShadowHeap {
int addr;
int data;
-} ShadowHeap;
+};
-typedef struct InstructionTrace {
+struct InstructionTrace {
int addr;
DecodedInstruction decInsn;
-} InstructionTrace;
+};
-typedef struct ShadowSpace {
+struct ShadowSpace {
const u2* startPC; /* starting pc of jitted region */
u4* fp; /* starting fp of jitted region */
const Method *method;
@@ -61,11 +57,12 @@
const void* endShadowFP; /* ending fp in shadow space */
InstructionTrace trace[JIT_MAX_TRACE_LEN]; /* opcode trace for debugging */
int traceLength; /* counter for current trace length */
-} ShadowSpace;
+};
/*
* Self verification functions.
*/
+extern "C" {
void* dvmSelfVerificationShadowSpaceAlloc(Thread* self);
void dvmSelfVerificationShadowSpaceFree(Thread* self);
void* dvmSelfVerificationSaveState(const u2* pc, u4* fp,
@@ -75,6 +72,7 @@
SelfVerificationState exitPoint,
Thread *self);
void dvmCheckSelfVerification(const u2* pc, Thread* self);
+}
#endif
/*
@@ -115,10 +113,10 @@
typedef s4 JitTraceCounter_t;
-typedef struct JitTraceProfCounters {
+struct JitTraceProfCounters {
unsigned int next;
JitTraceCounter_t *buckets[JIT_PROF_BLOCK_BUCKETS];
-} JitTraceProfCounters;
+};
/*
* Entries in the JIT's address lookup hash table.
@@ -126,7 +124,7 @@
* single 32-bit word to allow use of atomic update.
*/
-typedef struct JitEntryInfo {
+struct JitEntryInfo {
unsigned int isMethodEntry:1;
unsigned int inlineCandidate:1;
unsigned int profileEnabled:1;
@@ -134,19 +132,20 @@
unsigned int profileOffset:5;
unsigned int unused:5;
u2 chain; /* Index of next in chain */
-} JitEntryInfo;
+};
-typedef union JitEntryInfoUnion {
+union JitEntryInfoUnion {
JitEntryInfo info;
volatile int infoWord;
-} JitEntryInfoUnion;
+};
-typedef struct JitEntry {
+struct JitEntry {
JitEntryInfoUnion u;
const u2* dPC; /* Dalvik code address */
void* codeAddress; /* Code address of native translation */
-} JitEntry;
+};
+extern "C" {
void dvmCheckJit(const u2* pc, Thread* self);
void* dvmJitGetTraceAddr(const u2* dPC);
void* dvmJitGetMethodAddr(const u2* dPC);
@@ -162,7 +161,7 @@
void dvmJitStats(void);
bool dvmJitResizeJitTable(unsigned int size);
void dvmJitResetTable(void);
-struct JitEntry *dvmJitFindEntry(const u2* pc, bool isMethodEntry);
+JitEntry *dvmJitFindEntry(const u2* pc, bool isMethodEntry);
s8 dvmJitd2l(double d);
s8 dvmJitf2l(float f);
void dvmJitSetCodeAddr(const u2* dPC, void *nPC, JitInstructionSetType set,
@@ -176,9 +175,6 @@
void dvmJitUpdateThreadStateSingle(Thread* threead);
void dvmJitUpdateThreadStateAll(void);
void dvmJitResumeTranslation(Thread* self, const u2* pc, const u4* fp);
-
-#ifdef __cplusplus
}
-#endif
#endif /*_DALVIK_INTERP_JIT*/
diff --git a/vm/interp/Stack.cpp b/vm/interp/Stack.cpp
index 120726e..23d8049 100644
--- a/vm/interp/Stack.cpp
+++ b/vm/interp/Stack.cpp
@@ -780,10 +780,10 @@
return retObj;
}
-typedef struct LineNumFromPcContext {
+struct LineNumFromPcContext {
u4 address;
u4 lineNum;
-} LineNumFromPcContext;
+};
static int lineNumForPcCb(void *cnxt, u4 address, u4 lineNum)
{
diff --git a/vm/interp/Stack.h b/vm/interp/Stack.h
index 69dd3da..4e806b7 100644
--- a/vm/interp/Stack.h
+++ b/vm/interp/Stack.h
@@ -23,10 +23,6 @@
#include "jni.h"
#include <stdarg.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
Stack layout
@@ -111,7 +107,6 @@
struct StackSaveArea;
-typedef struct StackSaveArea StackSaveArea;
//#define PAD_SAVE_AREA /* help debug stack trampling */
@@ -274,15 +269,11 @@
/*
* Common handling for stack overflow.
*/
-void dvmHandleStackOverflow(Thread* self, const Method* method);
-void dvmCleanupStackOverflow(Thread* self, const Object* exception);
+extern "C" void dvmHandleStackOverflow(Thread* self, const Method* method);
+extern "C" void dvmCleanupStackOverflow(Thread* self, const Object* exception);
/* debugging; dvmDumpThread() is probably a better starting point */
void dvmDumpThreadStack(const DebugOutputTarget* target, Thread* thread);
void dvmDumpRunningThreadStack(const DebugOutputTarget* target, Thread* thread);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_INTERP_STACK*/
diff --git a/vm/jdwp/ExpandBuf.h b/vm/jdwp/ExpandBuf.h
index fea3a4d..6bdab0f 100644
--- a/vm/jdwp/ExpandBuf.h
+++ b/vm/jdwp/ExpandBuf.h
@@ -21,12 +21,7 @@
#include "Common.h" // need u1/u2/u4/u8 types
-#ifdef __cplusplus
-extern "C" {
-#endif
-
struct ExpandBuf; /* private */
-typedef struct ExpandBuf ExpandBuf;
/* create a new struct */
ExpandBuf* expandBufAlloc(void);
@@ -58,8 +53,4 @@
void expandBufAdd8BE(ExpandBuf* pBuf, u8 val);
void expandBufAddUtf8String(ExpandBuf* pBuf, const u1* str);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JDWP_EXPANDBUF*/
diff --git a/vm/jdwp/Jdwp.h b/vm/jdwp/Jdwp.h
index fb92e2a..9199a1e 100644
--- a/vm/jdwp/Jdwp.h
+++ b/vm/jdwp/Jdwp.h
@@ -30,12 +30,7 @@
#include "Bits.h"
#include <pthread.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
struct JdwpState; /* opaque */
-typedef struct JdwpState JdwpState;
/*
* Fundamental types.
@@ -82,34 +77,33 @@
/*
* Holds a JDWP "location".
*/
-typedef struct JdwpLocation {
+struct JdwpLocation {
u1 typeTag; /* class or interface? */
RefTypeId classId; /* method->clazz */
MethodId methodId; /* method in which "idx" resides */
u8 idx; /* relative index into code block */
-} JdwpLocation;
-//#define kJDWPLocationSize (25)
+};
/*
* How we talk to the debugger.
*/
-typedef enum JdwpTransportType {
+enum JdwpTransportType {
kJdwpTransportUnknown = 0,
kJdwpTransportSocket, /* transport=dt_socket */
kJdwpTransportAndroidAdb, /* transport=dt_android_adb */
-} JdwpTransportType;
+};
/*
* Holds collection of JDWP initialization parameters.
*/
-typedef struct JdwpStartupParams {
+struct JdwpStartupParams {
JdwpTransportType transport;
bool server;
bool suspend;
char host[64];
short port;
/* more will be here someday */
-} JdwpStartupParams;
+};
/*
* Perform one-time initialization.
@@ -239,8 +233,4 @@
void dvmJdwpDdmSendChunkV(JdwpState* state, int type, const struct iovec* iov,
int iovcnt);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JDWP_JDWP*/
diff --git a/vm/jdwp/JdwpConstants.cpp b/vm/jdwp/JdwpConstants.cpp
index 4b1418b..ab9d872 100644
--- a/vm/jdwp/JdwpConstants.cpp
+++ b/vm/jdwp/JdwpConstants.cpp
@@ -23,7 +23,7 @@
/*
* Return a string for the error code.
*/
-const char* dvmJdwpErrorStr(enum JdwpError error)
+const char* dvmJdwpErrorStr(JdwpError error)
{
switch (error) {
case ERR_NONE:
@@ -146,7 +146,7 @@
/*
* Return a string for the EventKind.
*/
-const char* dvmJdwpEventKindStr(enum JdwpEventKind kind)
+const char* dvmJdwpEventKindStr(JdwpEventKind kind)
{
switch (kind) {
case EK_SINGLE_STEP: return "SINGLE_STEP";
@@ -176,7 +176,7 @@
/*
* Return a string for the ModKind.
*/
-const char* dvmJdwpModKindStr(enum JdwpModKind kind)
+const char* dvmJdwpModKindStr(JdwpModKind kind)
{
switch (kind) {
case MK_COUNT: return "COUNT";
@@ -197,7 +197,7 @@
/*
* Return a string for the StepDepth.
*/
-const char* dvmJdwpStepDepthStr(enum JdwpStepDepth depth)
+const char* dvmJdwpStepDepthStr(JdwpStepDepth depth)
{
switch (depth) {
case SD_INTO: return "INTO";
@@ -210,7 +210,7 @@
/*
* Return a string for the StepSize.
*/
-const char* dvmJdwpStepSizeStr(enum JdwpStepSize size)
+const char* dvmJdwpStepSizeStr(JdwpStepSize size)
{
switch (size) {
case SS_MIN: return "MIN";
@@ -222,7 +222,7 @@
/*
* Return a string for the SuspendPolicy.
*/
-const char* dvmJdwpSuspendPolicyStr(enum JdwpSuspendPolicy policy)
+const char* dvmJdwpSuspendPolicyStr(JdwpSuspendPolicy policy)
{
switch (policy) {
case SP_NONE: return "NONE";
@@ -235,7 +235,7 @@
/*
* Return a string for the SuspendStatus.
*/
-const char* dvmJdwpSuspendStatusStr(enum JdwpSuspendStatus status)
+const char* dvmJdwpSuspendStatusStr(JdwpSuspendStatus status)
{
switch (status) {
case 0: return "Not SUSPENDED";
@@ -247,7 +247,7 @@
/*
* Return a string for the ThreadStatus.
*/
-const char* dvmJdwpThreadStatusStr(enum JdwpThreadStatus status)
+const char* dvmJdwpThreadStatusStr(JdwpThreadStatus status)
{
switch (status) {
case TS_ZOMBIE: return "ZOMBIE";
diff --git a/vm/jdwp/JdwpConstants.h b/vm/jdwp/JdwpConstants.h
index dc3a279..f3049e5 100644
--- a/vm/jdwp/JdwpConstants.h
+++ b/vm/jdwp/JdwpConstants.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_JDWP_JDWPCONSTANTS
#define _DALVIK_JDWP_JDWPCONSTANTS
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Error constants.
*/
@@ -84,8 +80,7 @@
ERR_NATIVE_METHOD = 511,
ERR_INVALID_COUNT = 512,
};
-typedef enum JdwpError JdwpError;
-const char* dvmJdwpErrorStr(enum JdwpError error);
+const char* dvmJdwpErrorStr(JdwpError error);
/*
@@ -123,7 +118,7 @@
EK_VM_START = EK_VM_INIT,
EK_THREAD_DEATH = EK_THREAD_END,
};
-const char* dvmJdwpEventKindStr(enum JdwpEventKind kind);
+const char* dvmJdwpEventKindStr(JdwpEventKind kind);
/*
* Values for "modKind" in EventRequest.Set.
@@ -141,7 +136,7 @@
MK_STEP = 10,
MK_INSTANCE_ONLY = 11,
};
-const char* dvmJdwpModKindStr(enum JdwpModKind kind);
+const char* dvmJdwpModKindStr(JdwpModKind kind);
/*
* InvokeOptions constants (bit flags).
@@ -159,7 +154,7 @@
SD_OVER = 1, /* step over method calls */
SD_OUT = 2, /* step out of current method */
};
-const char* dvmJdwpStepDepthStr(enum JdwpStepDepth depth);
+const char* dvmJdwpStepDepthStr(JdwpStepDepth depth);
/*
* StepSize constants.
@@ -168,7 +163,7 @@
SS_MIN = 0, /* step by minimum (e.g. 1 bytecode inst) */
SS_LINE = 1, /* if possible, step to next line */
};
-const char* dvmJdwpStepSizeStr(enum JdwpStepSize size);
+const char* dvmJdwpStepSizeStr(JdwpStepSize size);
/*
* SuspendPolicy constants.
@@ -178,7 +173,7 @@
SP_EVENT_THREAD = 1, /* suspend event thread */
SP_ALL = 2, /* suspend all threads */
};
-const char* dvmJdwpSuspendPolicyStr(enum JdwpSuspendPolicy policy);
+const char* dvmJdwpSuspendPolicyStr(JdwpSuspendPolicy policy);
/*
* SuspendStatus constants.
@@ -186,7 +181,7 @@
enum JdwpSuspendStatus {
SUSPEND_STATUS_SUSPENDED = 1,
};
-const char* dvmJdwpSuspendStatusStr(enum JdwpSuspendStatus status);
+const char* dvmJdwpSuspendStatusStr(JdwpSuspendStatus status);
/*
* ThreadStatus constants.
@@ -198,7 +193,7 @@
TS_MONITOR = 3, // WAITING (monitor wait)
TS_WAIT = 4, // (in Object.wait())
};
-const char* dvmJdwpThreadStatusStr(enum JdwpThreadStatus status);
+const char* dvmJdwpThreadStatusStr(JdwpThreadStatus status);
/*
* TypeTag constants.
@@ -231,8 +226,4 @@
JT_CLASS_OBJECT = 'c',
};
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JDWP_JDWPCONSTANTS*/
diff --git a/vm/jdwp/JdwpEvent.cpp b/vm/jdwp/JdwpEvent.cpp
index f93faaa..15f0b2a 100644
--- a/vm/jdwp/JdwpEvent.cpp
+++ b/vm/jdwp/JdwpEvent.cpp
@@ -100,7 +100,7 @@
* values for mods valid for the event being evaluated will be filled in.
* The rest will be zeroed.
*/
-typedef struct ModBasket {
+struct ModBasket {
const JdwpLocation* pLoc; /* LocationOnly */
const char* className; /* ClassMatch/ClassExclude */
ObjectId threadId; /* ThreadOnly */
@@ -110,7 +110,7 @@
FieldId field; /* FieldOnly */
ObjectId thisPtr; /* InstanceOnly */
/* nothing for StepOnly -- handled differently */
-} ModBasket;
+};
/*
* Get the next "request" serial number. We use this when sending
@@ -536,7 +536,7 @@
* DO NOT call this multiple times for the same eventKind, as Count mods are
* decremented during the scan.
*/
-static void findMatchingEvents(JdwpState* state, enum JdwpEventKind eventKind,
+static void findMatchingEvents(JdwpState* state, JdwpEventKind eventKind,
ModBasket* basket, JdwpEvent** matchList, int* pMatchCount)
{
/* start after the existing entries */
@@ -558,10 +558,10 @@
* Scan through the list of matches and determine the most severe
* suspension policy.
*/
-static enum JdwpSuspendPolicy scanSuspendPolicy(JdwpEvent** matchList,
+static JdwpSuspendPolicy scanSuspendPolicy(JdwpEvent** matchList,
int matchCount)
{
- enum JdwpSuspendPolicy policy = SP_NONE;
+ JdwpSuspendPolicy policy = SP_NONE;
while (matchCount--) {
if ((*matchList)->suspendPolicy > policy)
@@ -578,8 +578,7 @@
* SP_EVENT_THREAD - suspend ourselves
* SP_ALL - suspend everybody except JDWP support thread
*/
-static void suspendByPolicy(JdwpState* state,
- enum JdwpSuspendPolicy suspendPolicy)
+static void suspendByPolicy(JdwpState* state, JdwpSuspendPolicy suspendPolicy)
{
if (suspendPolicy == SP_NONE)
return;
@@ -745,7 +744,7 @@
*/
bool dvmJdwpPostVMStart(JdwpState* state, bool suspend)
{
- enum JdwpSuspendPolicy suspendPolicy;
+ JdwpSuspendPolicy suspendPolicy;
ObjectId threadId = dvmDbgGetThreadSelfId();
if (suspend)
@@ -811,7 +810,7 @@
bool dvmJdwpPostLocationEvent(JdwpState* state, const JdwpLocation* pLoc,
ObjectId thisPtr, int eventFlags)
{
- enum JdwpSuspendPolicy suspendPolicy = SP_NONE;
+ JdwpSuspendPolicy suspendPolicy = SP_NONE;
ModBasket basket;
char* nameAlloc = NULL;
@@ -920,7 +919,7 @@
*/
bool dvmJdwpPostThreadChange(JdwpState* state, ObjectId threadId, bool start)
{
- enum JdwpSuspendPolicy suspendPolicy = SP_NONE;
+ JdwpSuspendPolicy suspendPolicy = SP_NONE;
assert(threadId = dvmDbgGetThreadSelfId());
@@ -1024,7 +1023,7 @@
ObjectId exceptionId, RefTypeId exceptionClassId,
const JdwpLocation* pCatchLoc, ObjectId thisPtr)
{
- enum JdwpSuspendPolicy suspendPolicy = SP_NONE;
+ JdwpSuspendPolicy suspendPolicy = SP_NONE;
ModBasket basket;
char* nameAlloc = NULL;
@@ -1122,7 +1121,7 @@
bool dvmJdwpPostClassPrepare(JdwpState* state, int tag, RefTypeId refTypeId,
const char* signature, int status)
{
- enum JdwpSuspendPolicy suspendPolicy = SP_NONE;
+ JdwpSuspendPolicy suspendPolicy = SP_NONE;
ModBasket basket;
char* nameAlloc = NULL;
diff --git a/vm/jdwp/JdwpEvent.h b/vm/jdwp/JdwpEvent.h
index 110d0f2..1eb9b15 100644
--- a/vm/jdwp/JdwpEvent.h
+++ b/vm/jdwp/JdwpEvent.h
@@ -22,14 +22,10 @@
#include "JdwpConstants.h"
#include "ExpandBuf.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Event modifiers. A JdwpEvent may have zero or more of these.
*/
-typedef union JdwpEventMod {
+union JdwpEventMod {
u1 modKind; /* JdwpModKind */
struct {
u1 modKind;
@@ -80,24 +76,24 @@
u1 modKind;
ObjectId objectId;
} instanceOnly;
-} JdwpEventMod;
+};
/*
* One of these for every registered event.
*
* We over-allocate the struct to hold the modifiers.
*/
-typedef struct JdwpEvent {
- struct JdwpEvent* prev; /* linked list */
- struct JdwpEvent* next;
+struct JdwpEvent {
+ JdwpEvent* prev; /* linked list */
+ JdwpEvent* next;
- enum JdwpEventKind eventKind; /* what kind of event is this? */
- enum JdwpSuspendPolicy suspendPolicy; /* suspend all, none, or self? */
- int modCount; /* #of entries in mods[] */
- u4 requestId; /* serial#, reported to debugger */
+ JdwpEventKind eventKind; /* what kind of event is this? */
+ JdwpSuspendPolicy suspendPolicy; /* suspend all, none, or self? */
+ int modCount; /* #of entries in mods[] */
+ u4 requestId; /* serial#, reported to debugger */
- JdwpEventMod mods[1]; /* MUST be last field in struct */
-} JdwpEvent;
+ JdwpEventMod mods[1]; /* MUST be last field in struct */
+};
/*
* Allocate an event structure with enough space.
@@ -130,8 +126,4 @@
*/
bool dvmJdwpSendRequest(JdwpState* state, ExpandBuf* pReq);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JDWP_JDWPEVENT*/
diff --git a/vm/jdwp/JdwpHandler.cpp b/vm/jdwp/JdwpHandler.cpp
index 7776c83..930d25e 100644
--- a/vm/jdwp/JdwpHandler.cpp
+++ b/vm/jdwp/JdwpHandler.cpp
@@ -1713,12 +1713,12 @@
typedef JdwpError (*JdwpRequestHandler)(JdwpState* state,
const u1* buf, int dataLen, ExpandBuf* reply);
-typedef struct {
+struct JdwpHandlerMap {
u1 cmdSet;
u1 cmd;
JdwpRequestHandler func;
const char* descr;
-} JdwpHandlerMap;
+};
/*
* Map commands to functions.
diff --git a/vm/jdwp/JdwpHandler.h b/vm/jdwp/JdwpHandler.h
index 4486c9d..aade65d 100644
--- a/vm/jdwp/JdwpHandler.h
+++ b/vm/jdwp/JdwpHandler.h
@@ -22,19 +22,15 @@
#include "Common.h"
#include "ExpandBuf.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* JDWP message header for a request.
*/
-typedef struct JdwpReqHeader {
+struct JdwpReqHeader {
u4 length;
u4 id;
u1 cmdSet;
u1 cmd;
-} JdwpReqHeader;
+};
/*
* Process a request from the debugger.
@@ -48,8 +44,4 @@
/* helper function */
void dvmJdwpAddLocation(ExpandBuf* pReply, const JdwpLocation* pLoc);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JDWP_JDWPHANDLER*/
diff --git a/vm/jdwp/JdwpPriv.h b/vm/jdwp/JdwpPriv.h
index 8d78bbc..6b15fa9 100644
--- a/vm/jdwp/JdwpPriv.h
+++ b/vm/jdwp/JdwpPriv.h
@@ -28,10 +28,6 @@
#include <pthread.h>
#include <sys/uio.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* JDWP constants.
*/
@@ -47,14 +43,12 @@
* Transport-specific network status.
*/
struct JdwpNetState;
-typedef struct JdwpNetState JdwpNetState;
-
struct JdwpState;
/*
* Transport functions.
*/
-typedef struct JdwpTransport {
+struct JdwpTransport {
bool (*startup)(struct JdwpState* state, const JdwpStartupParams* pParams);
bool (*accept)(struct JdwpState* state);
bool (*establish)(struct JdwpState* state);
@@ -67,7 +61,7 @@
bool (*sendRequest)(struct JdwpState* state, ExpandBuf* pReq);
bool (*sendBufferedRequest)(struct JdwpState* state,
const struct iovec* iov, int iovcnt);
-} JdwpTransport;
+};
const JdwpTransport* dvmJdwpSocketTransport();
const JdwpTransport* dvmJdwpAndroidAdbTransport();
@@ -180,8 +174,4 @@
return (*state->transport->sendBufferedRequest)(state, iov, iovcnt);
}
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_JDWP_JDWPPRIV*/
diff --git a/vm/mterp/Mterp.h b/vm/mterp/Mterp.h
index 2dbc325..d68e0b1 100644
--- a/vm/mterp/Mterp.h
+++ b/vm/mterp/Mterp.h
@@ -26,15 +26,11 @@
#include "interp/Jit.h"
#endif
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Call this during initialization to verify that the values in asm-constants.h
* are still correct.
*/
-bool dvmCheckAsmConstants(void);
+extern "C" bool dvmCheckAsmConstants(void);
/*
* Local entry and exit points. The platform-specific implementation must
@@ -46,17 +42,13 @@
*
* The "mterp" interpreter is always "standard".
*/
-bool dvmMterpStdRun(Thread* self);
-void dvmMterpStdBail(Thread* self, bool changeInterp);
+extern "C" bool dvmMterpStdRun(Thread* self);
+extern "C" void dvmMterpStdBail(Thread* self, bool changeInterp);
/*
* Helper for common_printMethod(), invoked from the assembly
* interpreter.
*/
-void dvmMterpPrintMethod(Method* method);
-
-#ifdef __cplusplus
-}
-#endif
+extern "C" void dvmMterpPrintMethod(Method* method);
#endif /*_DALVIK_MTERP_MTERP*/
diff --git a/vm/mterp/common/FindInterface.h b/vm/mterp/common/FindInterface.h
index a640adb..72d45ff 100644
--- a/vm/mterp/common/FindInterface.h
+++ b/vm/mterp/common/FindInterface.h
@@ -17,9 +17,7 @@
/* common includes */
#include "Dalvik.h"
-#ifdef __cplusplus
extern "C" {
-#endif
/*
* Look up an interface on a class using the cache.
@@ -40,6 +38,4 @@
#undef ATOMIC_CACHE_CALC
}
-#ifdef __cplusplus
}
-#endif
diff --git a/vm/native/InternalNative.h b/vm/native/InternalNative.h
index 4d32de2..e6b210d 100644
--- a/vm/native/InternalNative.h
+++ b/vm/native/InternalNative.h
@@ -17,10 +17,6 @@
#ifndef _DALVIK_NATIVE_INTERNALNATIVE
#define _DALVIK_NATIVE_INTERNALNATIVE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Some setup for internal native functions.
*/
@@ -31,10 +27,6 @@
DalvikNativeFunc dvmLookupInternalNativeMethod(const Method* method);
/* exception-throwing stub for abstract methods (DalvikNativeFunc) */
-void dvmAbstractMethodStub(const u4* args, JValue* pResult);
-
-#ifdef __cplusplus
-}
-#endif
+extern "C" void dvmAbstractMethodStub(const u4* args, JValue* pResult);
#endif /*_DALVIK_NATIVE_INTERNALNATIVE*/
diff --git a/vm/native/InternalNativePriv.h b/vm/native/InternalNativePriv.h
index 35ab44c..440e60d 100644
--- a/vm/native/InternalNativePriv.h
+++ b/vm/native/InternalNativePriv.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_NATIVE_INTERNALNATIVEPRIV
#define _DALVIK_NATIVE_INTERNALNATIVEPRIV
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Return macros. Note we use "->i" instead of "->z" for boolean; this
* is because the interpreter expects everything to be a 32-bit value.
@@ -116,8 +112,4 @@
extern const DalvikNativeMethod dvm_org_apache_harmony_dalvik_NativeTestTarget[];
extern const DalvikNativeMethod dvm_sun_misc_Unsafe[];
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_NATIVE_INTERNALNATIVEPRIV*/
diff --git a/vm/native/dalvik_system_DexFile.cpp b/vm/native/dalvik_system_DexFile.cpp
index e4bf5cd..59dddfc 100644
--- a/vm/native/dalvik_system_DexFile.cpp
+++ b/vm/native/dalvik_system_DexFile.cpp
@@ -34,14 +34,14 @@
/*
* Internal struct for managing DexFile.
*/
-typedef struct DexOrJar {
+struct DexOrJar {
char* fileName;
bool isDex;
bool okayToFree;
RawDexFile* pRawDexFile;
JarFile* pJarFile;
u1* pDexMemory; // malloc()ed memory, if any
-} DexOrJar;
+};
/*
* (This is a dvmHashTableFree callback.)
diff --git a/vm/oo/AccessCheck.h b/vm/oo/AccessCheck.h
index 8633d89..105c9e1 100644
--- a/vm/oo/AccessCheck.h
+++ b/vm/oo/AccessCheck.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_OO_ACCESSCHECK
#define _DALVIK_OO_ACCESSCHECK
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Determine whether the "accessFrom" class is allowed to get at "clazz".
*/
@@ -44,8 +40,4 @@
*/
bool dvmInSamePackage(const ClassObject* class1, const ClassObject* class2);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_ACCESSCHECK*/
diff --git a/vm/oo/Array.h b/vm/oo/Array.h
index 3f8f253..9a5df52 100644
--- a/vm/oo/Array.h
+++ b/vm/oo/Array.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_OO_ARRAY
#define _DALVIK_OO_ARRAY
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Find a matching array class. If it doesn't exist, create it.
*
@@ -45,7 +41,7 @@
*
* Returns NULL with an exception raised if allocation fails.
*/
-ArrayObject* dvmAllocArrayByClass(ClassObject* arrayClass,
+extern "C" ArrayObject* dvmAllocArrayByClass(ClassObject* arrayClass,
size_t length, int allocFlags);
/*
@@ -141,8 +137,4 @@
*/
size_t dvmArrayClassElementWidth(const ClassObject* clazz);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_ARRAY*/
diff --git a/vm/oo/Class.cpp b/vm/oo/Class.cpp
index 2311f8a..259146b 100644
--- a/vm/oo/Class.cpp
+++ b/vm/oo/Class.cpp
@@ -937,10 +937,10 @@
*/
/* search for these criteria in the Class hash table */
-typedef struct ClassMatchCriteria {
+struct ClassMatchCriteria {
const char* descriptor;
Object* loader;
-} ClassMatchCriteria;
+};
#define kInitLoaderInc 4 /* must be power of 2 */
diff --git a/vm/oo/Class.h b/vm/oo/Class.h
index 83f6622..025989e 100644
--- a/vm/oo/Class.h
+++ b/vm/oo/Class.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_OO_CLASS
#define _DALVIK_OO_CLASS
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* The classpath and bootclasspath differ in that only the latter is
* consulted when looking for classes needed by the VM. When searching
@@ -39,19 +35,19 @@
* Ordering is significant. (Currently only ".dex" is supported directly
* by the VM.)
*/
-typedef enum {
+enum ClassPathEntryKind {
kCpeUnknown = 0,
kCpeDir,
kCpeJar,
kCpeDex,
kCpeLastEntry /* used as sentinel at end of array */
-} ClassPathEntryKind;
+};
-typedef struct ClassPathEntry {
+struct ClassPathEntry {
ClassPathEntryKind kind;
char* fileName;
void* ptr; /* JarFile* or DexFile* */
-} ClassPathEntry;
+};
bool dvmClassStartup(void);
void dvmClassShutdown(void);
@@ -134,7 +130,7 @@
/*
* Initialize a class.
*/
-bool dvmInitClass(ClassObject* clazz);
+extern "C" bool dvmInitClass(ClassObject* clazz);
/*
* Retrieve the system class loader.
@@ -287,8 +283,4 @@
*/
size_t dvmClassObjectSize(const ClassObject *clazz);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_CLASS*/
diff --git a/vm/oo/Object.h b/vm/oo/Object.h
index 55c4d1a..abc819a 100644
--- a/vm/oo/Object.h
+++ b/vm/oo/Object.h
@@ -24,10 +24,6 @@
#include <stddef.h>
#include "Atomic.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* fwd decl */
struct DataObject;
struct InitiatingLoaderList;
@@ -41,18 +37,6 @@
struct InstField;
struct Field;
struct RegisterMap;
-typedef struct DataObject DataObject;
-typedef struct InitiatingLoaderList InitiatingLoaderList;
-typedef struct ClassObject ClassObject;
-typedef struct StringObject StringObject;
-typedef struct ArrayObject ArrayObject;
-typedef struct Method Method;
-typedef struct ExceptionEntry ExceptionEntry;
-typedef struct LineNumEntry LineNumEntry;
-typedef struct StaticField StaticField;
-typedef struct InstField InstField;
-typedef struct Field Field;
-typedef struct RegisterMap RegisterMap;
/*
* Native function pointer type.
@@ -70,16 +54,16 @@
/* vm-internal access flags and related definitions */
-typedef enum AccessFlags {
+enum AccessFlags {
ACC_MIRANDA = 0x8000, // method (internal to VM)
JAVA_FLAGS_MASK = 0xffff, // bits set from Java sources (low 16)
-} AccessFlags;
+};
/* Use the top 16 bits of the access flags field for
* other class flags. Code should use the *CLASS_FLAG*()
* macros to set/get these flags.
*/
-typedef enum ClassFlags {
+enum ClassFlags {
CLASS_ISFINALIZABLE = (1<<31), // class/ancestor overrides finalize()
CLASS_ISARRAY = (1<<30), // class is a "[*"
CLASS_ISOBJECTARRAY = (1<<29), // class is a "[L*" or "[[*"
@@ -96,7 +80,7 @@
/* unlike the others, these can be present in the optimized DEX file */
CLASS_ISOPTIMIZED = (1<<17), // class may contain opt instrs
CLASS_ISPREVERIFIED = (1<<16), // class has been pre-verified
-} ClassFlags;
+};
/* bits we can reasonably expect to see set in a DEX access flags field */
#define EXPECTED_FILE_FLAGS \
@@ -121,9 +105,9 @@
* Use the top 16 bits of the access flags field for other method flags.
* Code should use the *METHOD_FLAG*() macros to set/get these flags.
*/
-typedef enum MethodFlags {
+enum MethodFlags {
METHOD_ISWRITABLE = (1<<31), // the method's code is writable
-} MethodFlags;
+};
/*
* Get/set method flags.
@@ -141,7 +125,7 @@
((u4)((method)->accessFlags & (flags)))
/* current state of the class, increasing as we progress */
-typedef enum ClassStatus {
+enum ClassStatus {
CLASS_ERROR = -1,
CLASS_NOTREADY = 0,
@@ -152,7 +136,7 @@
CLASS_VERIFIED = 5, /* logically part of linking; done pre-init */
CLASS_INITIALIZING = 6, /* class init in progress */
CLASS_INITIALIZED = 7, /* ready to go */
-} ClassStatus;
+};
/*
* Definitions for packing refOffsets in ClassObject.
@@ -196,7 +180,7 @@
/*
* Used for iftable in ClassObject.
*/
-typedef struct InterfaceEntry {
+struct InterfaceEntry {
/* pointer to interface class */
ClassObject* clazz;
@@ -205,7 +189,7 @@
* which holds the vtables for all interfaces declared by this class.
*/
int* methodIndexArray;
-} InterfaceEntry;
+};
@@ -221,7 +205,7 @@
*
* All objects have an Object header followed by type-specific data.
*/
-typedef struct Object {
+struct Object {
/* ptr to class object */
ClassObject* clazz;
@@ -230,7 +214,7 @@
* the comments in Sync.c for a description of its layout.
*/
u4 lock;
-} Object;
+};
/*
* Properly initialize an Object.
@@ -793,8 +777,4 @@
/* debugging */
void dvmDumpObject(const Object* obj);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_OBJECT*/
diff --git a/vm/oo/ObjectInlines.h b/vm/oo/ObjectInlines.h
index 1579a56..ef01834 100644
--- a/vm/oo/ObjectInlines.h
+++ b/vm/oo/ObjectInlines.h
@@ -20,10 +20,6 @@
#ifndef _DALVIK_OO_OBJECTINLINES
#define _DALVIK_OO_OBJECTINLINES
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* Store a single value in the array, and if the value isn't null,
* note in the write barrier.
@@ -358,8 +354,4 @@
}
}
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_OBJECTINLINES*/
diff --git a/vm/oo/Resolve.h b/vm/oo/Resolve.h
index 1403e77..5eb6814 100644
--- a/vm/oo/Resolve.h
+++ b/vm/oo/Resolve.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_OO_RESOLVE
#define _DALVIK_OO_RESOLVE
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* "Direct" and "virtual" methods are stored independently. The type of call
* used to invoke the method determines which list we search, and whether
@@ -31,13 +27,13 @@
* (<clinit>, <init>, and methods declared "private" or "static" are stored
* in the "direct" list. All others are stored in the "virtual" list.)
*/
-typedef enum MethodType {
+enum MethodType {
METHOD_UNKNOWN = 0,
METHOD_DIRECT, // <init>, private
METHOD_STATIC, // static
METHOD_VIRTUAL, // virtual, super
METHOD_INTERFACE // interface
-} MethodType;
+};
/*
* Resolve a class, given the referring class and a constant pool index
@@ -47,8 +43,9 @@
*
* Throws an exception and returns NULL on failure.
*/
-ClassObject* dvmResolveClass(const ClassObject* referrer, u4 classIdx,
- bool fromUnverifiedConstant);
+extern "C" ClassObject* dvmResolveClass(const ClassObject* referrer,
+ u4 classIdx,
+ bool fromUnverifiedConstant);
/*
* Resolve a direct, static, or virtual method.
@@ -58,8 +55,8 @@
*
* Throws an exception and returns NULL on failure.
*/
-Method* dvmResolveMethod(const ClassObject* referrer, u4 methodIdx,
- MethodType methodType);
+extern "C" Method* dvmResolveMethod(const ClassObject* referrer, u4 methodIdx,
+ MethodType methodType);
/*
* Resolve an interface method.
@@ -73,7 +70,8 @@
*
* Throws an exception and returns NULL on failure.
*/
-InstField* dvmResolveInstField(const ClassObject* referrer, u4 ifieldIdx);
+extern "C" InstField* dvmResolveInstField(const ClassObject* referrer,
+ u4 ifieldIdx);
/*
* Resolve a static field.
@@ -82,22 +80,19 @@
*
* Throws an exception and returns NULL on failure.
*/
-StaticField* dvmResolveStaticField(const ClassObject* referrer, u4 sfieldIdx);
+extern "C" StaticField* dvmResolveStaticField(const ClassObject* referrer,
+ u4 sfieldIdx);
/*
* Resolve a "const-string" reference.
*
* Throws an exception and returns NULL on failure.
*/
-StringObject* dvmResolveString(const ClassObject* referrer, u4 stringIdx);
+extern "C" StringObject* dvmResolveString(const ClassObject* referrer, u4 stringIdx);
/*
* Return debug string constant for enum.
*/
const char* dvmMethodTypeStr(MethodType methodType);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_RESOLVE*/
diff --git a/vm/oo/TypeCheck.h b/vm/oo/TypeCheck.h
index 07bae47..6ffdfe8 100644
--- a/vm/oo/TypeCheck.h
+++ b/vm/oo/TypeCheck.h
@@ -19,18 +19,14 @@
#ifndef _DALVIK_OO_TYPECHECK
#define _DALVIK_OO_TYPECHECK
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/* VM startup/shutdown */
bool dvmInstanceofStartup(void);
void dvmInstanceofShutdown(void);
/* used by dvmInstanceof; don't call */
-int dvmInstanceofNonTrivial(const ClassObject* instance,
- const ClassObject* clazz);
+extern "C" int dvmInstanceofNonTrivial(const ClassObject* instance,
+ const ClassObject* clazz);
/*
* Determine whether "instance" is an instance of "clazz".
@@ -76,11 +72,7 @@
*
* Returns 0 (false) if not, 1 (true) if so.
*/
-bool dvmCanPutArrayElement(const ClassObject* elemClass,
+extern "C" bool dvmCanPutArrayElement(const ClassObject* elemClass,
const ClassObject* arrayClass);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_OO_TYPECHECK*/
diff --git a/vm/reflect/Annotation.cpp b/vm/reflect/Annotation.cpp
index e0b91f4..6b33af3 100644
--- a/vm/reflect/Annotation.cpp
+++ b/vm/reflect/Annotation.cpp
@@ -283,11 +283,11 @@
* constants for processAnnotationValue indicating what style of
* result is wanted
*/
-typedef enum {
+enum AnnotationResultStyle {
kAllObjects, /* return everything as an object */
kAllRaw, /* return everything as a raw value or index */
kPrimitivesOrObjects /* return primitives as-is but the rest as objects */
-} AnnotationResultStyle;
+};
/*
* Recursively process an annotation value.
diff --git a/vm/reflect/Reflect.h b/vm/reflect/Reflect.h
index 21523eb..63260b5 100644
--- a/vm/reflect/Reflect.h
+++ b/vm/reflect/Reflect.h
@@ -19,10 +19,6 @@
#ifndef _DALVIK_REFLECT_REFLECT
#define _DALVIK_REFLECT_REFLECT
-#ifdef __cplusplus
-extern "C" {
-#endif
-
/*
* During startup, validate the "box" classes, e.g. java/lang/Integer.
*/
@@ -216,23 +212,23 @@
* Used to pass values out of annotation (and encoded array) processing
* functions.
*/
-typedef struct AnnotationValue {
+struct AnnotationValue {
JValue value;
u1 type;
-} AnnotationValue;
+};
/**
* Iterator structure for iterating over DexEncodedArray instances. The
* structure should be treated as opaque.
*/
-typedef struct {
+struct EncodedArrayIterator {
const u1* cursor; /* current cursor */
u4 elementsLeft; /* number of elements left to read */
const DexEncodedArray* encodedArray; /* instance being iterated over */
u4 size; /* number of elements in instance */
const ClassObject* clazz; /* class to resolve with respect to */
-} EncodedArrayIterator;
+};
/**
* Initializes an encoded array iterator.
@@ -264,8 +260,4 @@
bool dvmEncodedArrayIteratorGetNext(EncodedArrayIterator* iterator,
AnnotationValue* value);
-#ifdef __cplusplus
-}
-#endif
-
#endif /*_DALVIK_REFLECT_REFLECT*/
