Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Classes | Namespaces | Macros | Typedefs | Functions | Variables
globals.h File Reference
#include <arpa/inet.h>
#include <unistd.h>
#include <float.h>
#include <inttypes.h>
#include <limits.h>
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <cassert>
#include "platform/floating_point.h"

Go to the source code of this file.

Classes

struct  dart::simd128_value_t
 

Namespaces

namespace  dart
 

Macros

#define FALL_THROUGH   ((void)0)
 
#define NDEBUG
 
#define __STDC_FORMAT_MACROS
 
#define DEBUG_ONLY(code)
 
#define LIKELY(cond)   cond
 
#define UNLIKELY(cond)   cond
 
#define DART_UNUSED
 
#define DART_USED
 
#define Pd   PRIdPTR
 
#define Pu   PRIuPTR
 
#define Px   PRIxPTR
 
#define PX   PRIXPTR
 
#define Pd32   PRId32
 
#define Pu32   PRIu32
 
#define Px32   PRIx32
 
#define PX32   PRIX32
 
#define Pd64   PRId64
 
#define Pu64   PRIu64
 
#define Px64   PRIx64
 
#define PX64   PRIX64
 
#define Pp   "016" PRIxPTR
 
#define DART_INT64_C(x)   x##LL
 
#define DART_UINT64_C(x)   x##ULL
 
#define DART_2PART_UINT64_C(a, b)    (((static_cast<uint64_t>(a) << kBitsPerInt32) + 0x##b##u))
 
#define DISALLOW_COPY_AND_ASSIGN(TypeName)
 
#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName)
 
#define DISALLOW_ALLOCATION()
 
#define PRINTF_ATTRIBUTE(string_index, first_to_check)
 
#define PATH_MAX   MAX_PATH
 
#define INCLUDE_IL_PRINTER   1
 
#define FORCE_INCLUDE_DISASSEMBLER   1
 
#define DART_ENABLE_HEAP_SNAPSHOT_WRITER   1
 

Typedefs

typedef intptr_t dart::word
 
typedef uintptr_t dart::uword
 
typedef int32_t dart::classid_t
 

Functions

constexpr intptr_t dart::RoundWordsToKB (intptr_t size_in_words)
 
constexpr intptr_t dart::RoundWordsToMB (intptr_t size_in_words)
 
constexpr intptr_t dart::RoundWordsToGB (intptr_t size_in_words)
 
constexpr double dart::WordsToMB (intptr_t size_in_words)
 
constexpr double dart::MicrosecondsToSeconds (int64_t micros)
 
constexpr double dart::MicrosecondsToMilliseconds (int64_t micros)
 
template<typename T >
static void dart::USE (T &&)
 
template<class D , class S >
DART_FORCE_INLINE D dart::bit_cast (const S &source)
 
template<class D , class S >
DART_FORCE_INLINE D dart::bit_copy (const S &source)
 

Variables

constexpr intptr_t dart::kInt8SizeLog2 = 0
 
constexpr intptr_t dart::kInt8Size = 1 << kInt8SizeLog2
 
constexpr intptr_t dart::kInt16SizeLog2 = 1
 
constexpr intptr_t dart::kInt16Size = 1 << kInt16SizeLog2
 
constexpr intptr_t dart::kInt32SizeLog2 = 2
 
constexpr intptr_t dart::kInt32Size = 1 << kInt32SizeLog2
 
constexpr intptr_t dart::kInt64SizeLog2 = 3
 
constexpr intptr_t dart::kInt64Size = 1 << kInt64SizeLog2
 
constexpr intptr_t dart::kDoubleSize = sizeof(double)
 
constexpr intptr_t dart::kFloatSize = sizeof(float)
 
constexpr intptr_t dart::kQuadSize = 4 * kFloatSize
 
constexpr intptr_t dart::kSimd128Size = sizeof(simd128_value_t)
 
constexpr intptr_t dart::kBitsPerByteLog2 = 3
 
constexpr intptr_t dart::kBitsPerByte = 1 << kBitsPerByteLog2
 
constexpr intptr_t dart::kBitsPerInt8 = kInt8Size * kBitsPerByte
 
constexpr intptr_t dart::kBitsPerInt16 = kInt16Size * kBitsPerByte
 
constexpr intptr_t dart::kBitsPerInt32 = kInt32Size * kBitsPerByte
 
constexpr intptr_t dart::kBitsPerInt64 = kInt64Size * kBitsPerByte
 
constexpr int8_t dart::kMinInt8 = 0x80
 
constexpr int8_t dart::kMaxInt8 = 0x7F
 
constexpr uint8_t dart::kMaxUint8 = 0xFF
 
constexpr int16_t dart::kMinInt16 = 0x8000
 
constexpr int16_t dart::kMaxInt16 = 0x7FFF
 
constexpr uint16_t dart::kMaxUint16 = 0xFFFF
 
constexpr int32_t dart::kMinInt32 = 0x80000000
 
constexpr int32_t dart::kMaxInt32 = 0x7FFFFFFF
 
constexpr uint32_t dart::kMaxUint32 = 0xFFFFFFFF
 
constexpr int64_t dart::kMinInt64 = DART_INT64_C(0x8000000000000000)
 
constexpr int64_t dart::kMaxInt64 = DART_INT64_C(0x7FFFFFFFFFFFFFFF)
 
constexpr uint64_t dart::kMaxUint64 = DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF)
 
constexpr int dart::kMinInt = INT_MIN
 
constexpr int dart::kMaxInt = INT_MAX
 
constexpr int dart::kMaxUint = UINT_MAX
 
constexpr int64_t dart::kMinInt64RepresentableAsDouble = kMinInt64
 
constexpr int64_t dart::kMaxInt64RepresentableAsDouble
 
constexpr int64_t dart::kSignBitDouble = DART_INT64_C(0x8000000000000000)
 
constexpr intptr_t dart::kWordSizeLog2 = kInt64SizeLog2
 
constexpr intptr_t dart::kWordSize = 1 << kWordSizeLog2
 
constexpr intptr_t dart::kBitsPerWordLog2 = kWordSizeLog2 + kBitsPerByteLog2
 
constexpr intptr_t dart::kBitsPerWord = 1 << kBitsPerWordLog2
 
constexpr word dart::kWordMin = static_cast<uword>(1) << (kBitsPerWord - 1)
 
constexpr word dart::kWordMax = (static_cast<uword>(1) << (kBitsPerWord - 1)) - 1
 
constexpr uword dart::kUwordMax = static_cast<uword>(-1)
 
constexpr intptr_t dart::KBLog2 = 10
 
constexpr intptr_t dart::KB = 1 << KBLog2
 
constexpr intptr_t dart::MBLog2 = KBLog2 + KBLog2
 
constexpr intptr_t dart::MB = 1 << MBLog2
 
constexpr intptr_t dart::GBLog2 = MBLog2 + KBLog2
 
constexpr intptr_t dart::GB = 1 << GBLog2
 
constexpr intptr_t dart::KBInWordsLog2 = KBLog2 - kWordSizeLog2
 
constexpr intptr_t dart::KBInWords = 1 << KBInWordsLog2
 
constexpr intptr_t dart::MBInWordsLog2 = KBLog2 + KBInWordsLog2
 
constexpr intptr_t dart::MBInWords = 1 << MBInWordsLog2
 
constexpr intptr_t dart::GBInWordsLog2 = MBLog2 + KBInWordsLog2
 
constexpr intptr_t dart::GBInWords = 1 << GBInWordsLog2
 
constexpr intptr_t dart::kIntptrOne = 1
 
constexpr intptr_t dart::kIntptrMin = (kIntptrOne << (kBitsPerWord - 1))
 
constexpr intptr_t dart::kIntptrMax = ~kIntptrMin
 
constexpr intptr_t dart::kMillisecondsPerSecond = 1000
 
constexpr intptr_t dart::kMicrosecondsPerMillisecond = 1000
 
constexpr intptr_t dart::kMicrosecondsPerSecond
 
constexpr intptr_t dart::kNanosecondsPerMicrosecond = 1000
 
constexpr intptr_t dart::kNanosecondsPerMillisecond
 
constexpr intptr_t dart::kNanosecondsPerSecond
 

Macro Definition Documentation

◆ __STDC_FORMAT_MACROS

#define __STDC_FORMAT_MACROS

Definition at line 33 of file globals.h.

◆ DART_2PART_UINT64_C

#define DART_2PART_UINT64_C (   a,
  b 
)     (((static_cast<uint64_t>(a) << kBitsPerInt32) + 0x##b##u))

Definition at line 472 of file globals.h.

541 {
542 return (size_in_words + (KBInWords >> 1)) >> KBInWordsLog2;
543}
544constexpr intptr_t RoundWordsToMB(intptr_t size_in_words) {
545 return (size_in_words + (MBInWords >> 1)) >> MBInWordsLog2;
546}
547constexpr intptr_t RoundWordsToGB(intptr_t size_in_words) {
548 return (size_in_words + (GBInWords >> 1)) >> GBInWordsLog2;
549}
550constexpr double WordsToMB(intptr_t size_in_words) {
551 return static_cast<double>(size_in_words) / MBInWords;
552}
553
554constexpr intptr_t kIntptrOne = 1;
555constexpr intptr_t kIntptrMin = (kIntptrOne << (kBitsPerWord - 1));
556constexpr intptr_t kIntptrMax = ~kIntptrMin;
557
558// Time constants.
559constexpr intptr_t kMillisecondsPerSecond = 1000;
560constexpr intptr_t kMicrosecondsPerMillisecond = 1000;
561constexpr intptr_t kMicrosecondsPerSecond =
562 (kMicrosecondsPerMillisecond * kMillisecondsPerSecond);
563constexpr intptr_t kNanosecondsPerMicrosecond = 1000;
564constexpr intptr_t kNanosecondsPerMillisecond =
565 (kNanosecondsPerMicrosecond * kMicrosecondsPerMillisecond);
566constexpr intptr_t kNanosecondsPerSecond =
567 (kNanosecondsPerMicrosecond * kMicrosecondsPerSecond);
568
569// Helpers to scale micro second times to human understandable values.
570constexpr double MicrosecondsToSeconds(int64_t micros) {
571 return static_cast<double>(micros) / kMicrosecondsPerSecond;
572}
573constexpr double MicrosecondsToMilliseconds(int64_t micros) {
574 return static_cast<double>(micros) / kMicrosecondsPerMillisecond;
575}
576
577// A macro to disallow the copy constructor and operator= functions.
578// This should be used in the private: declarations for a class.
579#if !defined(DISALLOW_COPY_AND_ASSIGN)
580#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
581 private: \
582 TypeName(const TypeName&) = delete; \
583 void operator=(const TypeName&) = delete
584#endif // !defined(DISALLOW_COPY_AND_ASSIGN)
585
586// A macro to disallow all the implicit constructors, namely the default
587// constructor, copy constructor and operator= functions. This should be
588// used in the private: declarations for a class that wants to prevent
589// anyone from instantiating it. This is especially useful for classes
590// containing only static methods.
591#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
592#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
593 private: \
594 TypeName() = delete; \
595 DISALLOW_COPY_AND_ASSIGN(TypeName)
596#endif // !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
597
598// Macro to disallow allocation in the C++ heap. This should be used
599// in the private section for a class. Don't use UNREACHABLE here to
600// avoid circular dependencies between platform/globals.h and
601// platform/assert.h.
602#if !defined(DISALLOW_ALLOCATION)
603#define DISALLOW_ALLOCATION() \
604 public: \
605 void operator delete(void* pointer) { \
606 fprintf(stderr, "unreachable code\n"); \
607 abort(); \
608 } \
609 \
610 private: \
611 void* operator new(size_t size);
612#endif // !defined(DISALLOW_ALLOCATION)
613
614// The USE(x) template is used to silence C++ compiler warnings issued
615// for unused variables.
616template <typename T>
617static inline void USE(T&&) {}
618
619// The type-based aliasing rule allows the compiler to assume that
620// pointers of different types (for some definition of different)
621// never alias each other. Thus the following code does not work:
622//
623// float f = foo();
624// int fbits = *(int*)(&f);
625//
626// The compiler 'knows' that the int pointer can't refer to f since
627// the types don't match, so the compiler may cache f in a register,
628// leaving random data in fbits. Using C++ style casts makes no
629// difference, however a pointer to char data is assumed to alias any
630// other pointer. This is the 'memcpy exception'.
631//
632// The bit_cast function uses the memcpy exception to move the bits
633// from a variable of one type to a variable of another type. Of
634// course the end result is likely to be implementation dependent.
635// Most compilers (gcc-4.2 and MSVC 2005) will completely optimize
636// bit_cast away.
637//
638// There is an additional use for bit_cast. Recent gccs will warn when
639// they see casts that may result in breakage due to the type-based
640// aliasing rule. If you have checked that there is no breakage you
641// can use bit_cast to cast one pointer type to another. This confuses
642// gcc enough that it can no longer see that you have cast one pointer
643// type to another thus avoiding the warning.
644template <class D, class S>
645DART_FORCE_INLINE D bit_cast(const S& source) {
646 static_assert(sizeof(D) == sizeof(S),
647 "Source and destination must have the same size");
648
649 D destination;
650 // This use of memcpy is safe: source and destination cannot overlap.
651 memcpy(&destination, &source, sizeof(destination));
652 return destination;
653}
654
655// Similar to bit_cast, but allows copying from types of unrelated
656// sizes. This method was introduced to enable the strict aliasing
657// optimizations of GCC 4.4. Basically, GCC mindlessly relies on
658// obscure details in the C++ standard that make reinterpret_cast
659// virtually useless.
660template <class D, class S>
661DART_FORCE_INLINE D bit_copy(const S& source) {
662 D destination;
663 // This use of memcpy is safe: source and destination cannot overlap.
664 memcpy(&destination, reinterpret_cast<const void*>(&source),
665 sizeof(destination));
666 return destination;
667}
668
669// On Windows the reentrant version of strtok is called
670// strtok_s. Unify on the posix name strtok_r.
671#if defined(DART_HOST_OS_WINDOWS)
672#define snprintf _sprintf_p
673#define strtok_r strtok_s
674#endif
675
676#if !defined(DART_HOST_OS_WINDOWS)
677#if defined(TEMP_FAILURE_RETRY)
678// TEMP_FAILURE_RETRY is defined in unistd.h on some platforms. We should
679// not use that version, but instead the one in signal_blocker.h, to ensure
680// we disable signal interrupts.
681#undef TEMP_FAILURE_RETRY
682#endif // defined(TEMP_FAILURE_RETRY)
683#endif // !defined(DART_HOST_OS_WINDOWS)
684
685#if __GNUC__
686// Tell the compiler to do printf format string checking if the
687// compiler supports it; see the 'format' attribute in
688// <http://gcc.gnu.org/onlinedocs/gcc-4.3.0/gcc/Function-Attributes.html>.
689//
690// N.B.: As the GCC manual states, "[s]ince non-static C++ methods
691// have an implicit 'this' argument, the arguments of such methods
692// should be counted from two, not one."
693#define PRINTF_ATTRIBUTE(string_index, first_to_check) \
694 __attribute__((__format__(__printf__, string_index, first_to_check)))
695#else
696#define PRINTF_ATTRIBUTE(string_index, first_to_check)
697#endif
698
699#if defined(_WIN32)
700#define STDIN_FILENO 0
701#define STDOUT_FILENO 1
702#define STDERR_FILENO 2
703#endif
704
705#ifndef PATH_MAX
706// Most platforms use PATH_MAX, but in Windows it's called MAX_PATH.
707#define PATH_MAX MAX_PATH
708#endif
709
710// Undefine math.h definition which clashes with our condition names.
711#undef OVERFLOW
712
713// Include IL printer and disassembler functionality into non-PRODUCT builds,
714// in all AOT compiler builds or when forced.
715#if !defined(PRODUCT) || defined(DART_PRECOMPILER) || \
716 defined(FORCE_INCLUDE_DISASSEMBLER)
717#if defined(DART_PRECOMPILED_RUNTIME) && defined(PRODUCT)
718#error Requested to include IL printer into PRODUCT AOT runtime
719#endif
720#define INCLUDE_IL_PRINTER 1
721#if !defined(FORCE_INCLUDE_DISASSEMBLER)
722#define FORCE_INCLUDE_DISASSEMBLER 1
723#endif
724#endif
725
726// Include HeapSnapshotWriter functionality if not in PRODUCT.
727#if !defined(DART_ENABLE_HEAP_SNAPSHOT_WRITER) && !defined(PRODUCT)
728#define DART_ENABLE_HEAP_SNAPSHOT_WRITER 1
729#endif
730
731#if defined(DART_HOST_OS_ANDROID)
732#define kHostOperatingSystemName "android"
733#elif defined(DART_HOST_OS_FUCHSIA)
734#define kHostOperatingSystemName "fuchsia"
735#elif defined(DART_HOST_OS_IOS)
736#define kHostOperatingSystemName "ios"
737#elif defined(DART_HOST_OS_LINUX)
738#define kHostOperatingSystemName "linux"
739#elif defined(DART_HOST_OS_MACOS)
740#define kHostOperatingSystemName "macos"
741#elif defined(DART_HOST_OS_WINDOWS)
742#define kHostOperatingSystemName "windows"
743#else
744#error Host operating system detection failed.
745#endif
746
747#if defined(HOST_ARCH_ARM)
748#define kHostArchitectureName "arm"
749#elif defined(HOST_ARCH_ARM64)
750#define kHostArchitectureName "arm64"
751#elif defined(HOST_ARCH_IA32)
752#define kHostArchitectureName "ia32"
753#elif defined(HOST_ARCH_RISCV32)
754#define kHostArchitectureName "riscv32"
755#elif defined(HOST_ARCH_RISCV64)
756#define kHostArchitectureName "riscv64"
757#elif defined(HOST_ARCH_X64)
758#define kHostArchitectureName "x64"
759#else
760#error Host architecture detection failed.
761#endif
762
763#if defined(TARGET_ARCH_ARM)
764#define kTargetArchitectureName "arm"
765#elif defined(TARGET_ARCH_ARM64)
766#define kTargetArchitectureName "arm64"
767#elif defined(TARGET_ARCH_IA32)
768#define kTargetArchitectureName "ia32"
769#elif defined(TARGET_ARCH_RISCV32)
770#define kTargetArchitectureName "riscv32"
771#elif defined(TARGET_ARCH_RISCV64)
772#define kTargetArchitectureName "riscv64"
773#elif defined(TARGET_ARCH_X64)
774#define kTargetArchitectureName "x64"
775#else
776#error Target architecture detection failed.
777#endif
778
779// The ordering between DART_TARGET_OS_MACOS_IOS and DART_TARGET_OS_MACOS
780// below is important, since the latter is sometimes defined when the former
781// is, and sometimes not (e.g., ffi tests), so we need to test the former
782// before the latter.
783#if defined(DART_TARGET_OS_ANDROID)
784#define kTargetOperatingSystemName "android"
785#elif defined(DART_TARGET_OS_FUCHSIA)
786#define kTargetOperatingSystemName "fuchsia"
787#elif defined(DART_TARGET_OS_LINUX)
788#define kTargetOperatingSystemName "linux"
789#elif defined(DART_TARGET_OS_MACOS_IOS)
790#define kTargetOperatingSystemName "ios"
791#elif defined(DART_TARGET_OS_MACOS)
792#define kTargetOperatingSystemName "macos"
793#elif defined(DART_TARGET_OS_WINDOWS)
794#define kTargetOperatingSystemName "windows"
795#else
796#error Target operating system detection failed.
797#endif
798
799} // namespace dart
800
801#endif // RUNTIME_PLATFORM_GLOBALS_H_
source
SkBitmap source
Definition examples.cpp:28
kMicrosecondsPerMillisecond
constexpr uint64_t kMicrosecondsPerMillisecond
Definition fl_key_embedder_responder.cc:14
kMicrosecondsPerSecond
static constexpr int kMicrosecondsPerSecond
Definition FlutterViewController.mm:37
dart::MBInWordsLog2
constexpr intptr_t MBInWordsLog2
Definition globals.h:536
dart::MicrosecondsToSeconds
constexpr double MicrosecondsToSeconds(int64_t micros)
Definition globals.h:571
dart::bit_cast
DART_FORCE_INLINE D bit_cast(const S &source)
Definition globals.h:646
dart::kBitsPerWord
constexpr intptr_t kBitsPerWord
Definition globals.h:514
dart::kNanosecondsPerMillisecond
constexpr intptr_t kNanosecondsPerMillisecond
Definition globals.h:565
dart::RoundWordsToGB
constexpr intptr_t RoundWordsToGB(intptr_t size_in_words)
Definition globals.h:548
dart::RoundWordsToMB
constexpr intptr_t RoundWordsToMB(intptr_t size_in_words)
Definition globals.h:545
dart::kNanosecondsPerMicrosecond
constexpr intptr_t kNanosecondsPerMicrosecond
Definition globals.h:564
dart::kIntptrMin
constexpr intptr_t kIntptrMin
Definition globals.h:556
dart::kIntptrOne
constexpr intptr_t kIntptrOne
Definition globals.h:555
dart::kNanosecondsPerSecond
constexpr intptr_t kNanosecondsPerSecond
Definition globals.h:567
dart::WordsToMB
constexpr double WordsToMB(intptr_t size_in_words)
Definition globals.h:551
dart::kMillisecondsPerSecond
constexpr intptr_t kMillisecondsPerSecond
Definition globals.h:560
dart::USE
static void USE(T &&)
Definition globals.h:618
dart::KBInWordsLog2
constexpr intptr_t KBInWordsLog2
Definition globals.h:534
dart::GBInWordsLog2
constexpr intptr_t GBInWordsLog2
Definition globals.h:538
dart::MicrosecondsToMilliseconds
constexpr double MicrosecondsToMilliseconds(int64_t micros)
Definition globals.h:574
dart::bit_copy
DART_FORCE_INLINE D bit_copy(const S &source)
Definition globals.h:662
dart::kIntptrMax
constexpr intptr_t kIntptrMax
Definition globals.h:557
T
#define T
Definition precompiler.cc:65

◆ DART_ENABLE_HEAP_SNAPSHOT_WRITER

#define DART_ENABLE_HEAP_SNAPSHOT_WRITER   1

Definition at line 729 of file globals.h.

◆ DART_INT64_C

#define DART_INT64_C (   x)    x##LL

Definition at line 433 of file globals.h.

◆ DART_UINT64_C

#define DART_UINT64_C (   x)    x##ULL

Definition at line 434 of file globals.h.

◆ DART_UNUSED

#define DART_UNUSED

Definition at line 269 of file globals.h.

◆ DART_USED

#define DART_USED

Definition at line 277 of file globals.h.

◆ DEBUG_ONLY

#define DEBUG_ONLY (   code)

Definition at line 141 of file globals.h.

◆ DISALLOW_ALLOCATION

#define DISALLOW_ALLOCATION ( )
Value:
public: \
void operator delete(void* pointer) { \
fprintf(stderr, "unreachable code\n"); \
abort(); \
} \
\
private: \
void* operator new(size_t size);

Definition at line 604 of file globals.h.

605 : \
606 void operator delete(void* pointer) { \
607 fprintf(stderr, "unreachable code\n"); \
608 abort(); \
609 } \
610 \
611 private: \
612 void* operator new(size_t size);
flutter::size
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition switches.h:259

◆ DISALLOW_COPY_AND_ASSIGN

#define DISALLOW_COPY_AND_ASSIGN (   TypeName)
Value:
private: \
TypeName(const TypeName&) = delete; \
void operator=(const TypeName&) = delete

Definition at line 581 of file globals.h.

582 : \
583 TypeName(const TypeName&) = delete; \
584 void operator=(const TypeName&) = delete

◆ DISALLOW_IMPLICIT_CONSTRUCTORS

#define DISALLOW_IMPLICIT_CONSTRUCTORS (   TypeName)
Value:
private: \
TypeName() = delete; \
DISALLOW_COPY_AND_ASSIGN(TypeName)

Definition at line 593 of file globals.h.

594 : \
595 TypeName() = delete; \
596 DISALLOW_COPY_AND_ASSIGN(TypeName)

◆ FALL_THROUGH

#define FALL_THROUGH   ((void)0)

Definition at line 15 of file globals.h.

◆ FORCE_INCLUDE_DISASSEMBLER

#define FORCE_INCLUDE_DISASSEMBLER   1

Definition at line 723 of file globals.h.

◆ INCLUDE_IL_PRINTER

#define INCLUDE_IL_PRINTER   1

Definition at line 721 of file globals.h.

◆ LIKELY

#define LIKELY (   cond)    cond

Definition at line 260 of file globals.h.

◆ NDEBUG

#define NDEBUG

Definition at line 26 of file globals.h.

◆ PATH_MAX

#define PATH_MAX   MAX_PATH

Definition at line 708 of file globals.h.

◆ Pd

#define Pd   PRIdPTR

Definition at line 408 of file globals.h.

◆ Pd32

#define Pd32   PRId32

Definition at line 412 of file globals.h.

◆ Pd64

#define Pd64   PRId64

Definition at line 416 of file globals.h.

◆ Pp

#define Pp   "016" PRIxPTR

Definition at line 425 of file globals.h.

◆ PRINTF_ATTRIBUTE

#define PRINTF_ATTRIBUTE (   string_index,
  first_to_check 
)

Definition at line 697 of file globals.h.

◆ Pu

#define Pu   PRIuPTR

Definition at line 409 of file globals.h.

◆ Pu32

#define Pu32   PRIu32

Definition at line 413 of file globals.h.

◆ Pu64

#define Pu64   PRIu64

Definition at line 417 of file globals.h.

◆ Px

#define Px   PRIxPTR

Definition at line 410 of file globals.h.

◆ PX

#define PX   PRIXPTR

Definition at line 411 of file globals.h.

◆ Px32

#define Px32   PRIx32

Definition at line 414 of file globals.h.

◆ PX32

#define PX32   PRIX32

Definition at line 415 of file globals.h.

◆ Px64

#define Px64   PRIx64

Definition at line 418 of file globals.h.

◆ PX64

#define PX64   PRIX64

Definition at line 419 of file globals.h.

◆ UNLIKELY

#define UNLIKELY (   cond)    cond

Definition at line 261 of file globals.h.

Generated on Fri Apr 26 2024 06:18:29 for Flutter Engine by doxygen 1.9.8