17e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Copyright 2014 The Chromium Authors. All rights reserved. 27e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Use of this source code is governed by a BSD-style license that can be 37e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// found in the LICENSE file. 47e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 57e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// This file contains macros and macro-like constructs (e.g., templates) that 67e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// are commonly used throughout Chromium source. (It may also contain things 77e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// that are closely related to things that are commonly used that belong in this 87e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// file.) 97e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 107e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#ifndef BASE_MACROS_H_ 117e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define BASE_MACROS_H_ 127e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 137e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#include <stddef.h> // For size_t. 147e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#include <string.h> // For memcpy. 157e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 167e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#include "quipper/base/compiler_specific.h" // For ALLOW_UNUSED. 177e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 187e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Put this in the private: declarations for a class to be uncopyable. 197e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define DISALLOW_COPY(TypeName) \ 207e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh TypeName(const TypeName&) 217e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 227e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Put this in the private: declarations for a class to be unassignable. 237e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define DISALLOW_ASSIGN(TypeName) \ 247e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh void operator=(const TypeName&) 257e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 267e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// A macro to disallow the copy constructor and operator= functions 277e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// This should be used in the private: declarations for a class 287e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 297e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh TypeName(const TypeName&); \ 307e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh void operator=(const TypeName&) 317e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 327e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// An older, deprecated, politically incorrect name for the above. 337e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// NOTE: The usage of this macro was banned from our code base, but some 347e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// third_party libraries are yet using it. 357e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// TODO(tfarina): Figure out how to fix the usage of this macro in the 367e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// third_party libraries and get rid of it. 377e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define DISALLOW_EVIL_CONSTRUCTORS(TypeName) DISALLOW_COPY_AND_ASSIGN(TypeName) 387e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 397e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// A macro to disallow all the implicit constructors, namely the 407e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// default constructor, copy constructor and operator= functions. 417e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 427e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// This should be used in the private: declarations for a class 437e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// that wants to prevent anyone from instantiating it. This is 447e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// especially useful for classes containing only static methods. 457e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ 467e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh TypeName(); \ 477e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh DISALLOW_COPY_AND_ASSIGN(TypeName) 487e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 497e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The arraysize(arr) macro returns the # of elements in an array arr. 507e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The expression is a compile-time constant, and therefore can be 517e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// used in defining new arrays, for example. If you use arraysize on 527e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// a pointer by mistake, you will get a compile-time error. 537e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 547e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// One caveat is that arraysize() doesn't accept any array of an 557e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// anonymous type or a type defined inside a function. In these rare 567e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is 577e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// due to a limitation in C++'s template system. The limitation might 587e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// eventually be removed, but it hasn't happened yet. 597e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 607e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// This template function declaration is used in defining arraysize. 617e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Note that the function doesn't need an implementation, as we only 627e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// use its type. 637e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshtemplate <typename T, size_t N> 647e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshchar (&ArraySizeHelper(T (&array)[N]))[N]; 657e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 667e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// That gcc wants both of these prototypes seems mysterious. VC, for 677e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// its part, can't decide which to use (another mystery). Matching of 687e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// template overloads: the final frontier. 697e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#ifndef _MSC_VER 707e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshtemplate <typename T, size_t N> 717e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshchar (&ArraySizeHelper(const T (&array)[N]))[N]; 727e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#endif 737e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 747e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define arraysize(array) (sizeof(ArraySizeHelper(array))) 757e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 767e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize, 777e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// but can be used on anonymous types or types defined inside 787e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// functions. It's less safe than arraysize as it accepts some 797e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// (although not all) pointers. Therefore, you should use arraysize 807e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// whenever possible. 817e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 827e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type 837e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// size_t. 847e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 857e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// ARRAYSIZE_UNSAFE catches a few type errors. If you see a compiler error 867e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 877e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// "warning: division by zero in ..." 887e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 897e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer. 907e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays. 917e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 927e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The following comments are on the implementation details, and can 937e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// be ignored by the users. 947e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 957e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in 967e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// the array) and sizeof(*(arr)) (the # of bytes in one array 977e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// element). If the former is divisible by the latter, perhaps arr is 987e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// indeed an array, in which case the division result is the # of 997e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// elements in the array. Otherwise, arr cannot possibly be an array, 1007e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// and we generate a compiler error to prevent the code from 1017e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// compiling. 1027e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1037e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Since the size of bool is implementation-defined, we need to cast 1047e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final 1057e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// result has type size_t. 1067e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1077e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// This macro is not perfect as it wrongfully accepts certain 1087e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// pointers, namely where the pointer size is divisible by the pointee 1097e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// size. Since all our code has to go through a 32-bit compiler, 1107e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// where a pointer is 4 bytes, this means all pointers to a type whose 1117e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// size is 3 or greater than 4 will be (righteously) rejected. 1127e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 1137e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define ARRAYSIZE_UNSAFE(a) \ 1147e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh ((sizeof(a) / sizeof(*(a))) / \ 1157e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) 1167e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 1177e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 1187e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Use implicit_cast as a safe version of static_cast or const_cast 1197e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// for upcasting in the type hierarchy (i.e. casting a pointer to Foo 1207e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// to a pointer to SuperclassOfFoo or casting a pointer to Foo to 1217e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// a const pointer to Foo). 1227e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// When you use implicit_cast, the compiler checks that the cast is safe. 1237e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Such explicit implicit_casts are necessary in surprisingly many 1247e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// situations where C++ demands an exact type match instead of an 1257e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// argument type convertible to a target type. 1267e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1277e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The From type can be inferred, so the preferred syntax for using 1287e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// implicit_cast is the same as for static_cast etc.: 1297e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1307e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// implicit_cast<ToType>(expr) 1317e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1327e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// implicit_cast would have been part of the C++ standard library, 1337e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// but the proposal was submitted too late. It will probably make 1347e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// its way into the language in the future. 1357e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshtemplate<typename To, typename From> 1367e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshinline To implicit_cast(From const &f) { 1377e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh return f; 1387e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh} 1397e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 1407e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The COMPILE_ASSERT macro can be used to verify that a compile time 1417e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// expression is true. For example, you could use it to verify the 1427e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// size of a static array: 1437e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1447e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES, 1457e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// content_type_names_incorrect_size); 1467e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1477e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// or to make sure a struct is smaller than a certain size: 1487e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1497e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large); 1507e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1517e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The second argument to the macro is the name of the variable. If 1527e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// the expression is false, most compilers will issue a warning/error 1537e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// containing the name of the variable. 1547e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 1557e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#undef COMPILE_ASSERT 1567e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg) 1577e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 1587e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// bit_cast<Dest,Source> is a template function that implements the 1597e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// equivalent of "*reinterpret_cast<Dest*>(&source)". We need this in 1607e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// very low-level functions like the protobuf library and fast math 1617e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// support. 1627e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1637e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// float f = 3.14159265358979; 1647e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// int i = bit_cast<int32>(f); 1657e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// // i = 0x40490fdb 1667e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1677e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The classical address-casting method is: 1687e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1697e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// // WRONG 1707e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// float f = 3.14159265358979; // WRONG 1717e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// int i = * reinterpret_cast<int*>(&f); // WRONG 1727e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1737e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The address-casting method actually produces undefined behavior 1747e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// according to ISO C++ specification section 3.10 -15 -. Roughly, this 1757e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// section says: if an object in memory has one type, and a program 1767e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// accesses it with a different type, then the result is undefined 1777e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// behavior for most values of "different type". 1787e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1797e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// This is true for any cast syntax, either *(int*)&f or 1807e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// *reinterpret_cast<int*>(&f). And it is particularly true for 1817e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// conversions between integral lvalues and floating-point lvalues. 1827e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1837e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The purpose of 3.10 -15- is to allow optimizing compilers to assume 1847e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// that expressions with different types refer to different memory. gcc 1857e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 4.0.1 has an optimizer that takes advantage of this. So a 1867e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// non-conforming program quietly produces wildly incorrect output. 1877e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1887e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The problem is not the use of reinterpret_cast. The problem is type 1897e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// punning: holding an object in memory of one type and reading its bits 1907e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// back using a different type. 1917e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1927e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The C++ standard is more subtle and complex than this, but that 1937e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// is the basic idea. 1947e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1957e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Anyways ... 1967e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 1977e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// bit_cast<> calls memcpy() which is blessed by the standard, 1987e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// especially by the example in section 3.9 . Also, of course, 1997e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// bit_cast<> wraps up the nasty logic in one place. 2007e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 2017e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Fortunately memcpy() is very fast. In optimized mode, with a 2027e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline 2037e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// code with the minimal amount of data movement. On a 32-bit system, 2047e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8) 2057e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// compiles to two loads and two stores. 2067e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 2077e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// I tested this code with gcc 2.95.3, gcc 4.0.1, icc 8.1, and msvc 7.1. 2087e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 2097e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// WARNING: if Dest or Source is a non-POD type, the result of the memcpy 2107e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// is likely to surprise you. 2117e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2127e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshtemplate <class Dest, class Source> 2137e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshinline Dest bit_cast(const Source& source) { 2147e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh COMPILE_ASSERT(sizeof(Dest) == sizeof(Source), VerifySizesAreEqual); 2157e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2167e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh Dest dest; 2177e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh memcpy(&dest, &source, sizeof(dest)); 2187e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh return dest; 2197e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh} 2207e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2217e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Used to explicitly mark the return value of a function as unused. If you are 2227e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// really sure you don't want to do anything with the return value of a function 2237e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// that has been marked WARN_UNUSED_RESULT, wrap it with this. Example: 2247e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 2257e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// scoped_ptr<MyType> my_var = ...; 2267e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// if (TakeOwnership(my_var.get()) == SUCCESS) 2277e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// ignore_result(my_var.release()); 2287e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// 2297e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshtemplate<typename T> 2307e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshinline void ignore_result(const T&) { 2317e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh} 2327e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2337e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// The following enum should be used only as a constructor argument to indicate 2347e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// that the variable has static storage class, and that the constructor should 2357e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// do nothing to its state. It indicates to the reader that it is legal to 2367e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// declare a static instance of the class, provided the constructor is given 2377e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// the base::LINKER_INITIALIZED argument. Normally, it is unsafe to declare a 2387e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// static variable that has a constructor or a destructor because invocation 2397e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// order is undefined. However, IF the type can be initialized by filling with 2407e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// zeroes (which the loader does for static variables), AND the destructor also 2417e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// does nothing to the storage, AND there are no virtual methods, then a 2427e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// constructor declared as 2437e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// explicit MyClass(base::LinkerInitialized x) {} 2447e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// and invoked as 2457e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// static MyClass my_variable_name(base::LINKER_INITIALIZED); 2467e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshnamespace base { 2477e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntoshenum LinkerInitialized { LINKER_INITIALIZED }; 2487e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2497e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// Use these to declare and define a static local variable (static T;) so that 2507e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// it is leaked so that its destructors are not called at exit. If you need 2517e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh// thread-safe initialization, use base/lazy_instance.h instead. 2527e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#define CR_DEFINE_STATIC_LOCAL(type, name, arguments) \ 25399c536d4a58a78ec7b4fdd988f8be87f705825d5Chih-Hung Hsieh static type& name = *new type arguments /* NOLINT */ 2547e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2557e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh} // base 2567e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh 2577e2f4e9d384d501cf86118ebac4b8de2b86eac53Than McIntosh#endif // BASE_MACROS_H_ 258