1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Common defines for all Dalvik code.
*/
#ifndef DALVIK_COMMON_H_
#define DALVIK_COMMON_H_
#ifndef LOG_TAG
# define LOG_TAG "dalvikvm"
#endif
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <assert.h>
#include "cutils/log.h"
#if defined(HAVE_ENDIAN_H)
# include <endian.h>
#else /*not HAVE_ENDIAN_H*/
# define __BIG_ENDIAN 4321
# define __LITTLE_ENDIAN 1234
# if defined(HAVE_LITTLE_ENDIAN)
# define __BYTE_ORDER __LITTLE_ENDIAN
# else
# define __BYTE_ORDER __BIG_ENDIAN
# endif
#endif /*not HAVE_ENDIAN_H*/
#if !defined(NDEBUG) && defined(WITH_DALVIK_ASSERT)
# undef assert
# define assert(x) \
((x) ? ((void)0) : (ALOGE("ASSERT FAILED (%s:%d): %s", \
__FILE__, __LINE__, #x), *(int*)39=39, (void)0) )
#endif
#define MIN(x,y) (((x) < (y)) ? (x) : (y))
#define MAX(x,y) (((x) > (y)) ? (x) : (y))
#define LIKELY(exp) (__builtin_expect((exp) != 0, true))
#define UNLIKELY(exp) (__builtin_expect((exp) != 0, false))
#define ALIGN_UP(x, n) (((size_t)(x) + (n) - 1) & ~((n) - 1))
#define ALIGN_DOWN(x, n) ((size_t)(x) & -(n))
#define ALIGN_UP_TO_PAGE_SIZE(p) ALIGN_UP(p, SYSTEM_PAGE_SIZE)
#define ALIGN_DOWN_TO_PAGE_SIZE(p) ALIGN_DOWN(p, SYSTEM_PAGE_SIZE)
#define CLZ(x) __builtin_clz(x)
/*
* If "very verbose" logging is enabled, make it equivalent to ALOGV.
* Otherwise, make it disappear.
*
* Define this above the #include "Dalvik.h" to enable for only a
* single file.
*/
/* #define VERY_VERBOSE_LOG */
#if defined(VERY_VERBOSE_LOG)
# define LOGVV ALOGV
# define IF_LOGVV() IF_ALOGV()
#else
# define LOGVV(...) ((void)0)
# define IF_LOGVV() if (false)
#endif
/*
* These match the definitions in the VM specification.
*/
typedef uint8_t u1;
typedef uint16_t u2;
typedef uint32_t u4;
typedef uint64_t u8;
typedef int8_t s1;
typedef int16_t s2;
typedef int32_t s4;
typedef int64_t s8;
/*
* Storage for primitive types and object references.
*
* Some parts of the code (notably object field access) assume that values
* are "left aligned", i.e. given "JValue jv", "jv.i" and "*((s4*)&jv)"
* yield the same result. This seems to be guaranteed by gcc on big- and
* little-endian systems.
*/
struct Object;
union JValue {
#if defined(HAVE_LITTLE_ENDIAN)
u1 z;
s1 b;
u2 c;
s2 s;
s4 i;
s8 j;
float f;
double d;
Object* l;
#endif
#if defined(HAVE_BIG_ENDIAN)
struct {
u1 _z[3];
u1 z;
};
struct {
s1 _b[3];
s1 b;
};
struct {
u2 _c;
u2 c;
};
struct {
s2 _s;
s2 s;
};
s4 i;
s8 j;
float f;
double d;
void* l;
#endif
};
#define OFFSETOF_MEMBER(t, f) \
(reinterpret_cast<char*>( \
&reinterpret_cast<t*>(16)->f) - \
reinterpret_cast<char*>(16))
#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
#endif // DALVIK_COMMON_H_
|
