1 // -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*-
2 // Copyright (c) 2005, Google Inc.
3 // All rights reserved.
4 //
5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are
7 // met:
8 //
9 //     * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer.
11 //     * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the
14 // distribution.
15 //     * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 
31 #ifndef _BASICTYPES_H_
32 #define _BASICTYPES_H_
33 
34 #include <config.h>
35 #include <string.h>       // for memcpy()
36 #ifdef HAVE_INTTYPES_H
37 #include <inttypes.h>     // gets us PRId64, etc
38 #endif
39 
40 // To use this in an autoconf setting, make sure you run the following
41 // autoconf macros:
42 //    AC_HEADER_STDC              /* for stdint_h and inttypes_h */
43 //    AC_CHECK_TYPES([__int64])   /* defined in some windows platforms */
44 
45 #ifdef HAVE_INTTYPES_H
46 #include <inttypes.h>           // uint16_t might be here; PRId64 too.
47 #endif
48 #ifdef HAVE_STDINT_H
49 #include <stdint.h>             // to get uint16_t (ISO naming madness)
50 #endif
51 #include <sys/types.h>          // our last best hope for uint16_t
52 
53 // Standard typedefs
54 // All Google code is compiled with -funsigned-char to make "char"
55 // unsigned.  Google code therefore doesn't need a "uchar" type.
56 // TODO(csilvers): how do we make sure unsigned-char works on non-gcc systems?
57 typedef signed char         schar;
58 typedef int8_t              int8;
59 typedef int16_t             int16;
60 typedef int32_t             int32;
61 typedef int64_t             int64;
62 
63 // NOTE: unsigned types are DANGEROUS in loops and other arithmetical
64 // places.  Use the signed types unless your variable represents a bit
65 // pattern (eg a hash value) or you really need the extra bit.  Do NOT
66 // use 'unsigned' to express "this value should always be positive";
67 // use assertions for this.
68 
69 typedef uint8_t            uint8;
70 typedef uint16_t           uint16;
71 typedef uint32_t           uint32;
72 typedef uint64_t           uint64;
73 
74 const uint16 kuint16max = (   (uint16) 0xFFFF);
75 const uint32 kuint32max = (   (uint32) 0xFFFFFFFF);
76 const uint64 kuint64max = ( (((uint64) kuint32max) << 32) | kuint32max );
77 
78 const  int8  kint8max   = (   (  int8) 0x7F);
79 const  int16 kint16max  = (   ( int16) 0x7FFF);
80 const  int32 kint32max  = (   ( int32) 0x7FFFFFFF);
81 const  int64 kint64max =  ( ((( int64) kint32max) << 32) | kuint32max );
82 
83 const  int8  kint8min   = (   (  int8) 0x80);
84 const  int16 kint16min  = (   ( int16) 0x8000);
85 const  int32 kint32min  = (   ( int32) 0x80000000);
86 const  int64 kint64min =  ( (((uint64) kint32min) << 32) | 0 );
87 
88 // Define the "portable" printf and scanf macros, if they're not
89 // already there (via the inttypes.h we #included above, hopefully).
90 // Mostly it's old systems that don't support inttypes.h, so we assume
91 // they're 32 bit.
92 #ifndef PRIx64
93 #define PRIx64 "llx"
94 #endif
95 #ifndef SCNx64
96 #define SCNx64 "llx"
97 #endif
98 #ifndef PRId64
99 #define PRId64 "lld"
100 #endif
101 #ifndef SCNd64
102 #define SCNd64 "lld"
103 #endif
104 #ifndef PRIu64
105 #define PRIu64 "llu"
106 #endif
107 #ifndef PRIxPTR
108 #define PRIxPTR "lx"
109 #endif
110 
111 // Also allow for printing of a pthread_t.
112 #define GPRIuPTHREAD "lu"
113 #define GPRIxPTHREAD "lx"
114 #if defined(__CYGWIN__) || defined(__CYGWIN32__) || defined(__APPLE__) || defined(__FreeBSD__)
115 #define PRINTABLE_PTHREAD(pthreadt) reinterpret_cast<uintptr_t>(pthreadt)
116 #else
117 #define PRINTABLE_PTHREAD(pthreadt) pthreadt
118 #endif
119 
120 // A macro to disallow the evil copy constructor and operator= functions
121 // This should be used in the private: declarations for a class
122 #define DISALLOW_EVIL_CONSTRUCTORS(TypeName)    \
123   TypeName(const TypeName&);                    \
124   void operator=(const TypeName&)
125 
126 // An alternate name that leaves out the moral judgment... :-)
127 #define DISALLOW_COPY_AND_ASSIGN(TypeName) DISALLOW_EVIL_CONSTRUCTORS(TypeName)
128 
129 // The COMPILE_ASSERT macro can be used to verify that a compile time
130 // expression is true. For example, you could use it to verify the
131 // size of a static array:
132 //
133 //   COMPILE_ASSERT(sizeof(num_content_type_names) == sizeof(int),
134 //                  content_type_names_incorrect_size);
135 //
136 // or to make sure a struct is smaller than a certain size:
137 //
138 //   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
139 //
140 // The second argument to the macro is the name of the variable. If
141 // the expression is false, most compilers will issue a warning/error
142 // containing the name of the variable.
143 //
144 // Implementation details of COMPILE_ASSERT:
145 //
146 // - COMPILE_ASSERT works by defining an array type that has -1
147 //   elements (and thus is invalid) when the expression is false.
148 //
149 // - The simpler definition
150 //
151 //     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
152 //
153 //   does not work, as gcc supports variable-length arrays whose sizes
154 //   are determined at run-time (this is gcc's extension and not part
155 //   of the C++ standard).  As a result, gcc fails to reject the
156 //   following code with the simple definition:
157 //
158 //     int foo;
159 //     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
160 //                               // not a compile-time constant.
161 //
162 // - By using the type CompileAssert<(bool(expr))>, we ensures that
163 //   expr is a compile-time constant.  (Template arguments must be
164 //   determined at compile-time.)
165 //
166 // - The outter parentheses in CompileAssert<(bool(expr))> are necessary
167 //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
168 //
169 //     CompileAssert<bool(expr)>
170 //
171 //   instead, these compilers will refuse to compile
172 //
173 //     COMPILE_ASSERT(5 > 0, some_message);
174 //
175 //   (They seem to think the ">" in "5 > 0" marks the end of the
176 //   template argument list.)
177 //
178 // - The array size is (bool(expr) ? 1 : -1), instead of simply
179 //
180 //     ((expr) ? 1 : -1).
181 //
182 //   This is to avoid running into a bug in MS VC 7.1, which
183 //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
184 
185 template <bool>
186 struct CompileAssert {
187 };
188 
189 #ifdef HAVE___ATTRIBUTE__
190 # define ATTRIBUTE_UNUSED __attribute__((unused))
191 #else
192 # define ATTRIBUTE_UNUSED
193 #endif
194 
195 #define COMPILE_ASSERT(expr, msg)                               \
196   typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] ATTRIBUTE_UNUSED
197 
198 #define arraysize(a)  (sizeof(a) / sizeof(*(a)))
199 
200 #define OFFSETOF_MEMBER(strct, field)                                   \
201    (reinterpret_cast<char*>(&reinterpret_cast<strct*>(16)->field) -     \
202     reinterpret_cast<char*>(16))
203 
204 // bit_cast<Dest,Source> implements the equivalent of
205 // "*reinterpret_cast<Dest*>(&source)".
206 //
207 // The reinterpret_cast method would produce undefined behavior
208 // according to ISO C++ specification section 3.10 -15 -.
209 // bit_cast<> calls memcpy() which is blessed by the standard,
210 // especially by the example in section 3.9.
211 //
212 // Fortunately memcpy() is very fast.  In optimized mode, with a
213 // constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline
214 // code with the minimal amount of data movement.  On a 32-bit system,
215 // memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8)
216 // compiles to two loads and two stores.
217 
218 template <class Dest, class Source>
bit_cast(const Source & source)219 inline Dest bit_cast(const Source& source) {
220   COMPILE_ASSERT(sizeof(Dest) == sizeof(Source), bitcasting_unequal_sizes);
221   Dest dest;
222   memcpy(&dest, &source, sizeof(dest));
223   return dest;
224 }
225 
226 #ifdef HAVE___ATTRIBUTE__
227 # define ATTRIBUTE_WEAK      __attribute__((weak))
228 # define ATTRIBUTE_NOINLINE  __attribute__((noinline))
229 #else
230 # define ATTRIBUTE_WEAK
231 # define ATTRIBUTE_NOINLINE
232 #endif
233 
234 #if defined(HAVE___ATTRIBUTE__) && defined(__ELF__)
235 # define ATTRIBUTE_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
236 #else
237 # define ATTRIBUTE_VISIBILITY_HIDDEN
238 #endif
239 
240 // Section attributes are supported for both ELF and Mach-O, but in
241 // very different ways.  Here's the API we provide:
242 // 1) ATTRIBUTE_SECTION: put this with the declaration of all functions
243 //    you want to be in the same linker section
244 // 2) DEFINE_ATTRIBUTE_SECTION_VARS: must be called once per unique
245 //    name.  You want to make sure this is executed before any
246 //    DECLARE_ATTRIBUTE_SECTION_VARS; the easiest way is to put them
247 //    in the same .cc file.  Put this call at the global level.
248 // 3) INIT_ATTRIBUTE_SECTION_VARS: you can scatter calls to this in
249 //    multiple places to help ensure execution before any
250 //    DECLARE_ATTRIBUTE_SECTION_VARS.  You must have at least one
251 //    DEFINE, but you can have many INITs.  Put each in its own scope.
252 // 4) DECLARE_ATTRIBUTE_SECTION_VARS: must be called before using
253 //    ATTRIBUTE_SECTION_START or ATTRIBUTE_SECTION_STOP on a name.
254 //    Put this call at the global level.
255 // 5) ATTRIBUTE_SECTION_START/ATTRIBUTE_SECTION_STOP: call this to say
256 //    where in memory a given section is.  All functions declared with
257 //    ATTRIBUTE_SECTION are guaranteed to be between START and STOP.
258 
259 #if defined(HAVE___ATTRIBUTE__) && defined(__ELF__)
260 # define ATTRIBUTE_SECTION(name) __attribute__ ((section (#name)))
261 
262   // Weak section declaration to be used as a global declaration
263   // for ATTRIBUTE_SECTION_START|STOP(name) to compile and link
264   // even without functions with ATTRIBUTE_SECTION(name).
265 # define DECLARE_ATTRIBUTE_SECTION_VARS(name) \
266     extern char __start_##name[] ATTRIBUTE_WEAK; \
267     extern char __stop_##name[] ATTRIBUTE_WEAK
268 # define INIT_ATTRIBUTE_SECTION_VARS(name)     // no-op for ELF
269 # define DEFINE_ATTRIBUTE_SECTION_VARS(name)   // no-op for ELF
270 
271   // Return void* pointers to start/end of a section of code with functions
272   // having ATTRIBUTE_SECTION(name), or 0 if no such function exists.
273   // One must DECLARE_ATTRIBUTE_SECTION(name) for this to compile and link.
274 # define ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(__start_##name))
275 # define ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(__stop_##name))
276 # define HAVE_ATTRIBUTE_SECTION_START 1
277 
278 #elif defined(HAVE___ATTRIBUTE__) && defined(__MACH__)
279 # define ATTRIBUTE_SECTION(name) __attribute__ ((section ("__TEXT, " #name)))
280 
281 #include <mach-o/getsect.h>
282 #include <mach-o/dyld.h>
283 class AssignAttributeStartEnd {
284  public:
AssignAttributeStartEnd(const char * name,char ** pstart,char ** pend)285   AssignAttributeStartEnd(const char* name, char** pstart, char** pend) {
286     // Find out what dynamic library name is defined in
287     if (_dyld_present()) {
288       for (int i = _dyld_image_count() - 1; i >= 0; --i) {
289         const mach_header* hdr = _dyld_get_image_header(i);
290 #ifdef MH_MAGIC_64
291         if (hdr->magic == MH_MAGIC_64) {
292           uint64_t len;
293           *pstart = getsectdatafromheader_64((mach_header_64*)hdr,
294                                              "__TEXT", name, &len);
295           if (*pstart) {   // NULL if not defined in this dynamic library
296             *pstart += _dyld_get_image_vmaddr_slide(i);   // correct for reloc
297             *pend = *pstart + len;
298             return;
299           }
300         }
301 #endif
302         if (hdr->magic == MH_MAGIC) {
303           uint32_t len;
304           *pstart = getsectdatafromheader(hdr, "__TEXT", name, &len);
305           if (*pstart) {   // NULL if not defined in this dynamic library
306             *pstart += _dyld_get_image_vmaddr_slide(i);   // correct for reloc
307             *pend = *pstart + len;
308             return;
309           }
310         }
311       }
312     }
313     // If we get here, not defined in a dll at all.  See if defined statically.
314     unsigned long len;    // don't ask me why this type isn't uint32_t too...
315     *pstart = getsectdata("__TEXT", name, &len);
316     *pend = *pstart + len;
317   }
318 };
319 
320 #define DECLARE_ATTRIBUTE_SECTION_VARS(name)    \
321   extern char* __start_##name;                  \
322   extern char* __stop_##name
323 
324 #define INIT_ATTRIBUTE_SECTION_VARS(name)               \
325   DECLARE_ATTRIBUTE_SECTION_VARS(name);                 \
326   static const AssignAttributeStartEnd __assign_##name( \
327     #name, &__start_##name, &__stop_##name)
328 
329 #define DEFINE_ATTRIBUTE_SECTION_VARS(name)     \
330   char* __start_##name, *__stop_##name;         \
331   INIT_ATTRIBUTE_SECTION_VARS(name)
332 
333 # define ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(__start_##name))
334 # define ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(__stop_##name))
335 # define HAVE_ATTRIBUTE_SECTION_START 1
336 
337 #else  // not HAVE___ATTRIBUTE__ && __ELF__, nor HAVE___ATTRIBUTE__ && __MACH__
338 # define ATTRIBUTE_SECTION(name)
339 # define DECLARE_ATTRIBUTE_SECTION_VARS(name)
340 # define INIT_ATTRIBUTE_SECTION_VARS(name)
341 # define DEFINE_ATTRIBUTE_SECTION_VARS(name)
342 # define ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void*>(0))
343 # define ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void*>(0))
344 
345 #endif  // HAVE___ATTRIBUTE__ and __ELF__ or __MACH__
346 
347 #if defined(HAVE___ATTRIBUTE__)
348 # if (defined(__i386__) || defined(__x86_64__))
349 #   define CACHELINE_ALIGNED __attribute__((aligned(64)))
350 # elif (defined(__PPC__) || defined(__PPC64__))
351 #   define CACHELINE_ALIGNED __attribute__((aligned(16)))
352 # elif (defined(__arm__))
353 #   define CACHELINE_ALIGNED __attribute__((aligned(64)))
354     // some ARMs have shorter cache lines (ARM1176JZF-S is 32 bytes for example) but obviously 64-byte aligned implies 32-byte aligned
355 # elif (defined(__mips__))
356 #   define CACHELINE_ALIGNED __attribute__((aligned(128)))
357 # elif (defined(__aarch64__))
358 #   define CACHELINE_ALIGNED __attribute__((aligned(64)))
359     // implementation specific, Cortex-A53 and 57 should have 64 bytes
360 # elif (defined(__s390x__))
361 #   define CACHELINE_ALIGNED __attribute__((aligned(256)))
362 # else
363 #   error Could not determine cache line length - unknown architecture
364 # endif
365 #else
366 # define CACHELINE_ALIGNED
367 #endif  // defined(HAVE___ATTRIBUTE__) && (__i386__ || __x86_64__)
368 
369 // Structure for discovering alignment
370 union MemoryAligner {
371   void*  p;
372   double d;
373   size_t s;
374 } CACHELINE_ALIGNED;
375 
376 // The following enum should be used only as a constructor argument to indicate
377 // that the variable has static storage class, and that the constructor should
378 // do nothing to its state.  It indicates to the reader that it is legal to
379 // declare a static nistance of the class, provided the constructor is given
380 // the base::LINKER_INITIALIZED argument.  Normally, it is unsafe to declare a
381 // static variable that has a constructor or a destructor because invocation
382 // order is undefined.  However, IF the type can be initialized by filling with
383 // zeroes (which the loader does for static variables), AND the destructor also
384 // does nothing to the storage, then a constructor declared as
385 //       explicit MyClass(base::LinkerInitialized x) {}
386 // and invoked as
387 //       static MyClass my_variable_name(base::LINKER_INITIALIZED);
388 namespace base {
389 enum LinkerInitialized { LINKER_INITIALIZED };
390 }
391 
392 #endif  // _BASICTYPES_H_
393