1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
3 // See the LICENSE file in the project root for more information.
5 /*****************************************************************************/
8 /*****************************************************************************/
11 // clr.sln only defines _DEBUG
12 // The jit uses DEBUG rather than _DEBUG
13 // So we make sure that _DEBUG implies DEBUG
21 // Clang-format messes with the indentation of comments if they directly precede an
22 // ifdef. This macro allows us to anchor the comments to the regular flow of code.
23 #define CLANG_FORMAT_COMMENT_ANCHOR ;
25 // Clang-tidy replaces 0 with nullptr in some templated functions, causing a build
26 // break. Replacing those instances with ZERO avoids this change
30 // These don't seem useful, so turning them off is no big deal
31 #pragma warning(disable : 4065) // "switch statement contains 'default' but no 'case' labels" (happens due to #ifdefs)
32 #pragma warning(disable : 4510) // can't generate default constructor
33 #pragma warning(disable : 4511) // can't generate copy constructor
34 #pragma warning(disable : 4512) // can't generate assignment constructor
35 #pragma warning(disable : 4610) // user defined constructor required
36 #pragma warning(disable : 4211) // nonstandard extention used (char name[0] in structs)
37 #pragma warning(disable : 4127) // conditional expression constant
38 #pragma warning(disable : 4201) // "nonstandard extension used : nameless struct/union"
40 // Depending on the code base, you may want to not disable these
41 #pragma warning(disable : 4245) // assigning signed / unsigned
42 #pragma warning(disable : 4146) // unary minus applied to unsigned
44 #pragma warning(disable : 4100) // unreferenced formal parameter
45 #pragma warning(disable : 4291) // new operator without delete (only in emitX86.cpp)
49 #define CHECK_STRUCT_PADDING 0 // Set this to '1' to enable warning C4820 "'bytes' bytes padding added after
50 // construct 'member_name'" on interesting structs/classes
52 #define CHECK_STRUCT_PADDING 0 // Never enable it for non-MSFT compilers
57 #error Cannot define both _X86_ and _ARM_
60 #error Cannot define both _X86_ and _AMD64_
63 #error Cannot define both _X86_ and _ARM64_
66 #elif defined(_AMD64_)
68 #error Cannot define both _AMD64_ and _X86_
71 #error Cannot define both _AMD64_ and _ARM_
74 #error Cannot define both _AMD64_ and _ARM64_
79 #error Cannot define both _ARM_ and _X86_
82 #error Cannot define both _ARM_ and _AMD64_
85 #error Cannot define both _ARM_ and _ARM64_
88 #elif defined(_ARM64_)
90 #error Cannot define both _ARM64_ and _X86_
93 #error Cannot define both _ARM64_ and _AMD64_
96 #error Cannot define both _ARM64_ and _ARM_
100 #error Unsupported or unset host architecture
103 #if defined(_HOST_AMD64_) || defined(_HOST_ARM64_)
107 #if defined(_TARGET_X86_)
108 #if defined(_TARGET_ARM_)
109 #error Cannot define both _TARGET_X86_ and _TARGET_ARM_
111 #if defined(_TARGET_AMD64_)
112 #error Cannot define both _TARGET_X86_ and _TARGET_AMD64_
114 #if defined(_TARGET_ARM64_)
115 #error Cannot define both _TARGET_X86_ and _TARGET_ARM64_
117 #if !defined(_HOST_X86_)
118 #define _CROSS_COMPILER_
120 #elif defined(_TARGET_AMD64_)
121 #if defined(_TARGET_X86_)
122 #error Cannot define both _TARGET_AMD64_ and _TARGET_X86_
124 #if defined(_TARGET_ARM_)
125 #error Cannot define both _TARGET_AMD64_ and _TARGET_ARM_
127 #if defined(_TARGET_ARM64_)
128 #error Cannot define both _TARGET_AMD64_ and _TARGET_ARM64_
130 #if !defined(_HOST_AMD64_)
131 #define _CROSS_COMPILER_
133 #elif defined(_TARGET_ARM_)
134 #if defined(_TARGET_X86_)
135 #error Cannot define both _TARGET_ARM_ and _TARGET_X86_
137 #if defined(_TARGET_AMD64_)
138 #error Cannot define both _TARGET_ARM_ and _TARGET_AMD64_
140 #if defined(_TARGET_ARM64_)
141 #error Cannot define both _TARGET_ARM_ and _TARGET_ARM64_
143 #if !defined(_HOST_ARM_)
144 #define _CROSS_COMPILER_
146 #elif defined(_TARGET_ARM64_)
147 #if defined(_TARGET_X86_)
148 #error Cannot define both _TARGET_ARM64_ and _TARGET_X86_
150 #if defined(_TARGET_AMD64_)
151 #error Cannot define both _TARGET_ARM64_ and _TARGET_AMD64_
153 #if defined(_TARGET_ARM_)
154 #error Cannot define both _TARGET_ARM64_ and _TARGET_ARM_
156 #if !defined(_HOST_ARM64_)
157 #define _CROSS_COMPILER_
160 #error Unsupported or unset target architecture
163 #if defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
164 #ifndef _TARGET_64BIT_
165 #define _TARGET_64BIT_
166 #endif // _TARGET_64BIT_
167 #endif // defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
169 #ifdef _TARGET_64BIT_
171 #error Cannot define both _TARGET_X86_ and _TARGET_64BIT_
172 #endif // _TARGET_X86_
174 #error Cannot define both _TARGET_ARM_ and _TARGET_64BIT_
175 #endif // _TARGET_ARM_
176 #endif // _TARGET_64BIT_
178 #if defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
179 #define _TARGET_XARCH_
182 #if defined(_TARGET_ARM_) || defined(_TARGET_ARM64_)
183 #define _TARGET_ARMARCH_
186 // If the UNIX_AMD64_ABI is defined make sure that _TARGET_AMD64_ is also defined.
187 #if defined(UNIX_AMD64_ABI)
188 #if !defined(_TARGET_AMD64_)
189 #error When UNIX_AMD64_ABI is defined you must define _TARGET_AMD64_ defined as well.
193 // If the UNIX_X86_ABI is defined make sure that _TARGET_X86_ is also defined.
194 #if defined(UNIX_X86_ABI)
195 #if !defined(_TARGET_X86_)
196 #error When UNIX_X86_ABI is defined you must define _TARGET_X86_ defined as well.
200 #if defined(PLATFORM_UNIX)
204 // Are we generating code to target Unix? This is true if we will run on Unix (_HOST_UNIX_ is defined).
205 // It's also true if we are building an altjit targetting Unix, which we determine by checking if either
206 // UNIX_AMD64_ABI or UNIX_X86_ABI is defined.
207 #if defined(_HOST_UNIX_) || ((defined(UNIX_AMD64_ABI) || defined(UNIX_X86_ABI)) && defined(ALT_JIT))
208 #define _TARGET_UNIX_
211 // --------------------------------------------------------------------------------
212 // IMAGE_FILE_MACHINE_TARGET
213 // --------------------------------------------------------------------------------
215 #if defined(_TARGET_X86_)
216 #define IMAGE_FILE_MACHINE_TARGET IMAGE_FILE_MACHINE_I386
217 #elif defined(_TARGET_AMD64_)
218 #define IMAGE_FILE_MACHINE_TARGET IMAGE_FILE_MACHINE_AMD64
219 #elif defined(_TARGET_ARM_)
220 #define IMAGE_FILE_MACHINE_TARGET IMAGE_FILE_MACHINE_ARMNT
221 #elif defined(_TARGET_ARM64_)
222 #define IMAGE_FILE_MACHINE_TARGET IMAGE_FILE_MACHINE_ARM64 // 0xAA64
224 #error Unsupported or unset target architecture
227 // Include the AMD64 unwind codes when appropriate.
228 #if defined(_TARGET_AMD64_)
229 // We need to temporarily set PLATFORM_UNIX, if necessary, to get the Unix-specific unwind codes.
230 #if defined(_TARGET_UNIX_) && !defined(_HOST_UNIX_)
231 #define PLATFORM_UNIX
233 #include "win64unwind.h"
234 #if defined(_TARGET_UNIX_) && !defined(_HOST_UNIX_)
243 #define __OPERATOR_NEW_INLINE 1 // indicate that I will define these
244 #define __PLACEMENT_NEW_INLINE // don't bring in the global placement new, it is easy to make a mistake
245 // with our new(compiler*) pattern.
247 #include "utilcode.h" // this defines assert as _ASSERTE
248 #include "host.h" // this redefines assert for the JIT to use assertAbort
253 #define INDEBUG_COMMA(x) x,
254 #define DEBUGARG(x) , x
257 #define INDEBUG_COMMA(x)
261 #if defined(DEBUG) || defined(LATE_DISASM)
262 #define INDEBUG_LDISASM_COMMA(x) x,
264 #define INDEBUG_LDISASM_COMMA(x)
267 #if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
268 #define FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(x) , x
269 #define FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY(x) x
270 #else // !defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
271 #define FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(x)
272 #define FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY(x)
273 #endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
275 #if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING) || (!defined(_TARGET_64BIT_) && !defined(LEGACY_BACKEND))
276 #define FEATURE_PUT_STRUCT_ARG_STK 1
277 #define PUT_STRUCT_ARG_STK_ONLY_ARG(x) , x
278 #define PUT_STRUCT_ARG_STK_ONLY(x) x
279 #else // !(defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)|| (!defined(_TARGET_64BIT_) && !defined(LEGACY_BACKEND)))
280 #define PUT_STRUCT_ARG_STK_ONLY_ARG(x)
281 #define PUT_STRUCT_ARG_STK_ONLY(x)
282 #endif // !(defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)|| (!defined(_TARGET_64BIT_) && !defined(LEGACY_BACKEND)))
284 #if defined(UNIX_AMD64_ABI)
285 #define UNIX_AMD64_ABI_ONLY_ARG(x) , x
286 #define UNIX_AMD64_ABI_ONLY(x) x
287 #else // !defined(UNIX_AMD64_ABI)
288 #define UNIX_AMD64_ABI_ONLY_ARG(x)
289 #define UNIX_AMD64_ABI_ONLY(x)
290 #endif // defined(UNIX_AMD64_ABI)
292 #if defined(UNIX_AMD64_ABI) || defined(_TARGET_ARM64_)
293 #define MULTIREG_HAS_SECOND_GC_RET 1
294 #define MULTIREG_HAS_SECOND_GC_RET_ONLY_ARG(x) , x
295 #define MULTIREG_HAS_SECOND_GC_RET_ONLY(x) x
296 #else // !defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
297 #define MULTIREG_HAS_SECOND_GC_RET 0
298 #define MULTIREG_HAS_SECOND_GC_RET_ONLY_ARG(x)
299 #define MULTIREG_HAS_SECOND_GC_RET_ONLY(x)
300 #endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
302 // To get rid of warning 4701 : local variable may be used without being initialized
303 #define DUMMY_INIT(x) (x)
305 #define REGEN_SHORTCUTS 0
306 #define REGEN_CALLPAT 0
308 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
309 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
313 XX Interface of the JIT with jit.cpp XX
315 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
316 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
319 /*****************************************************************************/
323 #define INFO6 LL_INFO10000 // Did Jit or Inline succeeded?
324 #define INFO7 LL_INFO100000 // NYI stuff
325 #define INFO8 LL_INFO1000000 // Weird failures
326 #define INFO9 LL_EVERYTHING // Info about incoming settings
327 #define INFO10 LL_EVERYTHING // Totally verbose
331 typedef class ICorJitInfo* COMP_HANDLE;
333 const CORINFO_CLASS_HANDLE NO_CLASS_HANDLE = (CORINFO_CLASS_HANDLE) nullptr;
335 /*****************************************************************************/
340 } // Use to disable code while keeping prefast happy
342 // We define two IL offset types, as follows:
344 // IL_OFFSET: either a distinguished value, or an IL offset.
345 // IL_OFFSETX: either a distinguished value, or the top two bits are a flags, and the remaining bottom
346 // bits are a IL offset.
348 // In both cases, the set of legal distinguished values is:
349 // BAD_IL_OFFSET -- A unique illegal IL offset number. Note that it must be different from
350 // the ICorDebugInfo values, below, and must also not be a legal IL offset.
351 // ICorDebugInfo::NO_MAPPING -- The IL offset corresponds to no source code (such as EH step blocks).
352 // ICorDebugInfo::PROLOG -- The IL offset indicates a prolog
353 // ICorDebugInfo::EPILOG -- The IL offset indicates an epilog
355 // The IL offset must be in the range [0 .. 0x3fffffff]. This is because we steal
356 // the top two bits in IL_OFFSETX for flags, but we want the maximum range to be the same
357 // for both types. The IL value can't be larger than the maximum IL offset of the function
360 // Blocks and statements never store one of the ICorDebugInfo values, even for IL_OFFSETX types. These are
361 // only stored in the IPmappingDsc struct, ipmdILoffsx field.
363 typedef unsigned IL_OFFSET;
365 const IL_OFFSET BAD_IL_OFFSET = 0x80000000;
366 const IL_OFFSET MAX_IL_OFFSET = 0x3fffffff;
368 typedef unsigned IL_OFFSETX; // IL_OFFSET with stack-empty or call-instruction bit
369 const IL_OFFSETX IL_OFFSETX_STKBIT = 0x80000000; // Note: this bit is set when the stack is NOT empty!
370 const IL_OFFSETX IL_OFFSETX_CALLINSTRUCTIONBIT = 0x40000000; // Set when the IL offset is for a call instruction.
371 const IL_OFFSETX IL_OFFSETX_BITS = IL_OFFSETX_STKBIT | IL_OFFSETX_CALLINSTRUCTIONBIT;
373 IL_OFFSET jitGetILoffs(IL_OFFSETX offsx);
374 IL_OFFSET jitGetILoffsAny(IL_OFFSETX offsx);
375 bool jitIsStackEmpty(IL_OFFSETX offsx);
376 bool jitIsCallInstruction(IL_OFFSETX offsx);
378 const unsigned BAD_VAR_NUM = UINT_MAX;
380 // Code can't be more than 2^31 in any direction. This is signed, so it should be used for anything that is
381 // relative to something else.
382 typedef int NATIVE_OFFSET;
384 // This is the same as the above, but it's used in absolute contexts (i.e. offset from the start). Also,
385 // this is used for native code sizes.
386 typedef unsigned UNATIVE_OFFSET;
388 typedef ptrdiff_t ssize_t;
390 // For the following specially handled FIELD_HANDLES we need
391 // values that are negative and have the low two bits zero
392 // See eeFindJitDataOffs and eeGetJitDataOffs in Compiler.hpp
393 #define FLD_GLOBAL_DS ((CORINFO_FIELD_HANDLE)-4)
394 #define FLD_GLOBAL_FS ((CORINFO_FIELD_HANDLE)-8)
396 /*****************************************************************************/
400 /*****************************************************************************/
402 // Late disassembly is OFF by default. Can be turned ON by
403 // adding /DLATE_DISASM=1 on the command line.
404 // Always OFF in the non-debug version
406 #if defined(LATE_DISASM) && (LATE_DISASM == 0)
410 /*****************************************************************************/
412 /*****************************************************************************/
414 #define FEATURE_VALNUM_CSE 1 // enable the Value Number CSE optimization logic
416 // true if Value Number CSE is enabled
417 #define FEATURE_ANYCSE FEATURE_VALNUM_CSE
419 #define CSE_INTO_HANDLERS 0
421 #define LARGE_EXPSET 1 // Track 64 or 32 assertions/copies/consts/rangechecks
422 #define ASSERTION_PROP 1 // Enable value/assertion propagation
424 #define LOCAL_ASSERTION_PROP ASSERTION_PROP // Enable local assertion propagation
426 //=============================================================================
428 #define OPT_BOOL_OPS 1 // optimize boolean operations
430 //=============================================================================
432 #define REDUNDANT_LOAD 1 // track locals in regs, suppress loads
433 #define STACK_PROBES 0 // Support for stack probes
434 #define DUMP_FLOWGRAPHS DEBUG // Support for creating Xml Flowgraph reports in *.fgx files
436 #define HANDLER_ENTRY_MUST_BE_IN_HOT_SECTION 1 // if 1 we must have all handler entry points in the Hot code section
438 /*****************************************************************************/
440 #define VPTR_OFFS 0 // offset of vtable pointer from obj ptr
442 /*****************************************************************************/
444 #define DUMP_GC_TABLES DEBUG
445 #define VERIFY_GC_TABLES 0
446 #define REARRANGE_ADDS 1
448 #define FUNC_INFO_LOGGING 1 // Support dumping function info to a file. In retail, only NYIs, with no function name,
451 /*****************************************************************************/
452 /*****************************************************************************/
453 /* Set these to 1 to collect and output various statistics about the JIT */
455 #define CALL_ARG_STATS 0 // Collect stats about calls and call arguments.
456 #define COUNT_BASIC_BLOCKS 0 // Create a histogram of basic block sizes, and a histogram of IL sizes in the simple
457 // case of single block methods.
458 #define COUNT_LOOPS 0 // Collect stats about loops, such as the total number of natural loops, a histogram of
459 // the number of loop exits, etc.
460 #define COUNT_RANGECHECKS 0 // Count range checks removed (in lexical CSE?).
461 #define DATAFLOW_ITER 0 // Count iterations in lexical CSE and constant folding dataflow.
462 #define DISPLAY_SIZES 0 // Display generated code, data, and GC information sizes.
463 #define MEASURE_BLOCK_SIZE 0 // Collect stats about basic block and flowList node sizes and memory allocations.
464 #define MEASURE_FATAL 0 // Count the number of calls to fatal(), including NYIs and noway_asserts.
465 #define MEASURE_NODE_SIZE 0 // Collect stats about GenTree node allocations.
466 #define MEASURE_PTRTAB_SIZE 0 // Collect stats about GC pointer table allocations.
467 #define EMITTER_STATS 0 // Collect stats on the emitter.
468 #define NODEBASH_STATS 0 // Collect stats on changed gtOper values in GenTree's.
469 #define COUNT_AST_OPERS 0 // Display use counts for GenTree operators.
471 #define VERBOSE_SIZES 0 // Always display GC info sizes. If set, DISPLAY_SIZES must also be set.
472 #define VERBOSE_VERIFY 0 // Dump additional information when verifying code. Useful to debug verification bugs.
475 #define MEASURE_MEM_ALLOC 1 // Collect memory allocation stats.
476 #define LOOP_HOIST_STATS 1 // Collect loop hoisting stats.
477 #define TRACK_LSRA_STATS 1 // Collect LSRA stats
479 #define MEASURE_MEM_ALLOC 0 // You can set this to 1 to get memory stats in retail, as well
480 #define LOOP_HOIST_STATS 0 // You can set this to 1 to get loop hoist stats in retail, as well
481 #define TRACK_LSRA_STATS 0 // You can set this to 1 to get LSRA stats in retail, as well
484 // Timing calls to clr.dll is only available under certain conditions.
485 #ifndef FEATURE_JIT_METHOD_PERF
486 #define MEASURE_CLRAPI_CALLS 0 // Can't time these calls without METHOD_PERF.
489 #define MEASURE_CLRAPI_CALLS 0 // No point in measuring DEBUG code.
491 #if !defined(_HOST_X86_) && !defined(_HOST_AMD64_)
492 #define MEASURE_CLRAPI_CALLS 0 // Cycle counters only hooked up on x86/x64.
494 #if !defined(_MSC_VER) && !defined(__clang__)
495 #define MEASURE_CLRAPI_CALLS 0 // Only know how to do this with VC and Clang.
498 // If none of the above set the flag to 0, it's available.
499 #ifndef MEASURE_CLRAPI_CALLS
500 #define MEASURE_CLRAPI_CALLS 0 // Set to 1 to measure time in ICorJitInfo calls.
503 /*****************************************************************************/
504 /* Portability Defines */
505 /*****************************************************************************/
507 #define JIT32_GCENCODER
510 /*****************************************************************************/
512 /*****************************************************************************/
519 #pragma message("NOTE: this non-debug build has GC ptr table dumping always enabled!")
520 const bool dspGCtbls = true;
523 /*****************************************************************************/
527 #define JITDUMP(...) \
529 if (JitTls::GetCompiler()->verbose) \
536 #define JITLOG_THIS(t, x) \
540 #define DBEXEC(flg, expr) \
545 #define DISPNODE(t) \
546 if (JitTls::GetCompiler()->verbose) \
547 JitTls::GetCompiler()->gtDispTree(t, nullptr, nullptr, true);
548 #define DISPTREE(t) \
549 if (JitTls::GetCompiler()->verbose) \
550 JitTls::GetCompiler()->gtDispTree(t);
551 #define DISPRANGE(range) \
552 if (JitTls::GetCompiler()->verbose) \
553 JitTls::GetCompiler()->gtDispRange(range);
554 #define DISPTREERANGE(range, t) \
555 if (JitTls::GetCompiler()->verbose) \
556 JitTls::GetCompiler()->gtDispTreeRange(range, t);
557 #define VERBOSE JitTls::GetCompiler()->verbose
561 #define JITLOG_THIS(t, x)
562 #define DBEXEC(flg, expr)
565 #define DISPRANGE(range)
566 #define DISPTREERANGE(range, t)
570 /*****************************************************************************
572 * Double alignment. This aligns ESP to 0 mod 8 in function prolog, then uses ESP
573 * to reference locals, EBP to reference parameters.
574 * It only makes sense if frameless method support is on.
575 * (frameless method support is now always on)
579 #define DOUBLE_ALIGN 1 // permit the double alignment of ESP in prolog,
580 // and permit the double alignment of local offsets
582 #define DOUBLE_ALIGN 0 // no special handling for double alignment
584 /*****************************************************************************/
586 extern void _cdecl debugStop(const char* why, ...);
588 /*****************************************************************************/
594 const char* methodName; // Method to display output for
595 const char* className; // Class to display output for
597 double CGknob; // Tweakable knob for testing
598 unsigned testMask; // Tweakable mask for testing
600 JitOptions* lastDummyField; // Ensures instantiation uses right order of arguments
603 extern JitOptions jitOpts;
605 // Forward declarations for UninitializedWord and IsUninitialized are needed by alloc.h
606 template <typename T>
607 inline T UninitializedWord(Compiler* comp);
609 template <typename T>
610 inline bool IsUninitialized(T data);
614 /*****************************************************************************/
625 /*****************************************************************************/
627 #define castto(var, typ) (*(typ*)&var)
629 #define sizeto(typ, mem) (offsetof(typ, mem) + sizeof(((typ*)0)->mem))
631 /*****************************************************************************/
633 #ifdef NO_MISALIGNED_ACCESS
635 #define MISALIGNED_RD_I2(src) (*castto(src, char*) | *castto(src + 1, char*) << 8)
637 #define MISALIGNED_RD_U2(src) (*castto(src, char*) | *castto(src + 1, char*) << 8)
639 #define MISALIGNED_WR_I2(dst, val) \
640 *castto(dst, char*) = val; \
641 *castto(dst + 1, char*) = val >> 8;
643 #define MISALIGNED_WR_I4(dst, val) \
644 *castto(dst, char*) = val; \
645 *castto(dst + 1, char*) = val >> 8; \
646 *castto(dst + 2, char*) = val >> 16; \
647 *castto(dst + 3, char*) = val >> 24;
651 #define MISALIGNED_RD_I2(src) (*castto(src, short*))
652 #define MISALIGNED_RD_U2(src) (*castto(src, unsigned short*))
654 #define MISALIGNED_WR_I2(dst, val) *castto(dst, short*) = val;
655 #define MISALIGNED_WR_I4(dst, val) *castto(dst, int*) = val;
657 #define MISALIGNED_WR_ST(dst, val) *castto(dst, ssize_t*) = val;
661 /*****************************************************************************/
663 inline size_t roundUp(size_t size, size_t mult = sizeof(size_t))
665 assert(mult && ((mult & (mult - 1)) == 0)); // power of two test
667 return (size + (mult - 1)) & ~(mult - 1);
670 inline size_t roundDn(size_t size, size_t mult = sizeof(size_t))
672 assert(mult && ((mult & (mult - 1)) == 0)); // power of two test
674 return (size) & ~(mult - 1);
677 inline unsigned int unsigned_abs(int x)
679 return ((unsigned int)abs(x));
682 #ifdef _TARGET_64BIT_
683 inline size_t unsigned_abs(ssize_t x)
685 return ((size_t)abs(x));
687 #endif // _TARGET_64BIT_
689 /*****************************************************************************/
691 #if CALL_ARG_STATS || COUNT_BASIC_BLOCKS || COUNT_LOOPS || EMITTER_STATS || MEASURE_NODE_SIZE || MEASURE_MEM_ALLOC
693 #define HISTOGRAM_MAX_SIZE_COUNT 64
698 Histogram(const unsigned* const sizeTable);
700 void dump(FILE* output);
701 void record(unsigned size);
704 void ensureAllocated();
706 unsigned m_sizeCount;
707 const unsigned* const m_sizeTable;
708 unsigned m_counts[HISTOGRAM_MAX_SIZE_COUNT];
711 #endif // CALL_ARG_STATS || COUNT_BASIC_BLOCKS || COUNT_LOOPS || EMITTER_STATS || MEASURE_NODE_SIZE
713 /*****************************************************************************/
716 #include "icapctrl.h"
719 /*****************************************************************************/
723 /*****************************************************************************/
725 #if CHECK_STRUCT_PADDING
726 #pragma warning(push)
727 #pragma warning(default : 4820) // 'bytes' bytes padding added after construct 'member_name'
728 #endif // CHECK_STRUCT_PADDING
732 #if FEATURE_TAILCALL_OPT
734 #ifdef FEATURE_CORECLR
735 // CoreCLR - enable tail call opt for the following IL pattern
742 #define FEATURE_TAILCALL_OPT_SHARED_RETURN 1
744 // Desktop: Keep this to zero as one of app-compat apps that is using GetCallingAssembly()
745 // has an issue turning this ON.
747 // Refer to TF: Bug: 824625 and its associated regression TF Bug: 1113265
748 #define FEATURE_TAILCALL_OPT_SHARED_RETURN 0
749 #endif // FEATURE_CORECLR
751 #else // !FEATURE_TAILCALL_OPT
752 #define FEATURE_TAILCALL_OPT_SHARED_RETURN 0
753 #endif // !FEATURE_TAILCALL_OPT
755 #define CLFLG_CODESIZE 0x00001
756 #define CLFLG_CODESPEED 0x00002
757 #define CLFLG_CSE 0x00004
758 #define CLFLG_REGVAR 0x00008
759 #define CLFLG_RNGCHKOPT 0x00010
760 #define CLFLG_DEADASGN 0x00020
761 #define CLFLG_CODEMOTION 0x00040
762 #define CLFLG_QMARK 0x00080
763 #define CLFLG_TREETRANS 0x00100
764 #define CLFLG_INLINING 0x00200
765 #define CLFLG_CONSTANTFOLD 0x00800
767 #if FEATURE_STRUCTPROMOTE
768 #define CLFLG_STRUCTPROMOTE 0x00400
770 #define CLFLG_STRUCTPROMOTE 0x00000
773 #define CLFLG_MAXOPT \
774 (CLFLG_CSE | CLFLG_REGVAR | CLFLG_RNGCHKOPT | CLFLG_DEADASGN | CLFLG_CODEMOTION | CLFLG_QMARK | CLFLG_TREETRANS | \
775 CLFLG_INLINING | CLFLG_STRUCTPROMOTE | CLFLG_CONSTANTFOLD)
777 #define CLFLG_MINOPT (CLFLG_TREETRANS)
779 #define JIT_RESERVED_STACK 64 // Reserved for arguments of calls and hidden
780 // pushes for finallys so that we don't
781 // probe on every call site. See comment in
782 // for CORINFO_STACKPROBE_DEPTH in corjit.h
784 /*****************************************************************************/
786 extern void dumpILBytes(const BYTE* const codeAddr, unsigned codeSize, unsigned alignSize);
788 extern unsigned dumpSingleInstr(const BYTE* const codeAddr, IL_OFFSET offs, const char* prefix = nullptr);
790 extern void dumpILRange(const BYTE* const codeAddr, unsigned codeSize); // in bytes
792 /*****************************************************************************/
794 extern int jitNativeCode(CORINFO_METHOD_HANDLE methodHnd,
795 CORINFO_MODULE_HANDLE classHnd,
797 CORINFO_METHOD_INFO* methodInfo,
798 void** methodCodePtr,
799 ULONG* methodCodeSize,
800 JitFlags* compileFlags,
801 void* inlineInfoPtr);
804 const size_t INVALID_POINTER_VALUE = 0xFEEDFACEABADF00D;
806 const size_t INVALID_POINTER_VALUE = 0xFEEDFACE;
809 // Constants for making sure size_t fit into smaller types.
810 const size_t MAX_USHORT_SIZE_T = static_cast<size_t>(static_cast<unsigned short>(-1));
811 const size_t MAX_UNSIGNED_SIZE_T = static_cast<size_t>(static_cast<unsigned>(-1));
813 // These assume 2's complement...
814 const int MAX_SHORT_AS_INT = 32767;
815 const int MIN_SHORT_AS_INT = -32768;
817 /*****************************************************************************/
819 // CompMemKind values are used to tag memory allocations performed via
820 // the compiler's allocator so that the memory usage of various compiler
821 // components can be tracked separately (when MEASURE_MEM_ALLOC is defined).
825 #define CompMemKindMacro(kind) CMK_##kind,
826 #include "compmemkind.h"
832 // Allows general purpose code (e.g. collection classes) to allocate memory
833 // of a pre-determined kind via the compiler's allocator.
837 Compiler* const m_comp;
838 #if MEASURE_MEM_ALLOC
839 CompMemKind const m_cmk;
842 CompAllocator(Compiler* comp, CompMemKind cmk)
844 #if MEASURE_MEM_ALLOC
850 // Allocates a block of memory at least `sz` in size.
851 // Zero-length allocation are not allowed.
852 inline void* Alloc(size_t sz);
854 // Allocates a block of memory at least `elems * elemSize` in size.
855 // Zero-length allocation are not allowed.
856 inline void* ArrayAlloc(size_t elems, size_t elemSize);
858 // For the compiler's ArenaAllocator, free operations are no-ops.
864 // Global operator new overloads that work with CompAllocator
866 inline void* __cdecl operator new(size_t n, CompAllocator* alloc)
868 return alloc->Alloc(n);
871 inline void* __cdecl operator new[](size_t n, CompAllocator* alloc)
873 return alloc->Alloc(n);
876 // A CompAllocator wrapper that implements IAllocator and allows zero-length
877 // memory allocations (the compiler's ArenAllocator does not support zero-length
880 class CompIAllocator : public IAllocator
882 CompAllocator* const m_alloc;
883 char m_zeroLenAllocTarg;
886 CompIAllocator(CompAllocator* alloc) : m_alloc(alloc)
890 // Allocates a block of memory at least `sz` in size.
891 virtual void* Alloc(size_t sz) override
895 return &m_zeroLenAllocTarg;
899 return m_alloc->Alloc(sz);
903 // Allocates a block of memory at least `elems * elemSize` in size.
904 virtual void* ArrayAlloc(size_t elemSize, size_t numElems) override
906 if ((elemSize == 0) || (numElems == 0))
908 return &m_zeroLenAllocTarg;
912 return m_alloc->ArrayAlloc(elemSize, numElems);
916 // Frees the block of memory pointed to by p.
917 virtual void Free(void* p) override
926 Compiler* m_compiler;
932 JitTls(ICorJitInfo* jitInfo);
936 static LogEnv* GetLogEnv();
939 static Compiler* GetCompiler();
940 static void SetCompiler(Compiler* compiler);
944 // Include the definition of Compiler for use by these template functions
946 #include "compiler.h"
948 //****************************************************************************
950 // Returns a word filled with the JITs allocator default fill value.
952 template <typename T>
953 inline T UninitializedWord(Compiler* comp)
955 unsigned char defaultFill = 0xdd;
958 comp = JitTls::GetCompiler();
960 defaultFill = comp->compGetJitDefaultFill();
961 assert(defaultFill <= 0xff);
962 __int64 word = 0x0101010101010101LL * defaultFill;
966 //****************************************************************************
968 // Tries to determine if this value is coming from uninitialized JIT memory
969 // - Returns true if the value matches what we initialized the memory to.
972 // - Asserts that use this are assuming that the UninitializedWord value
973 // isn't a legal value for 'data'. Thus using a default fill value of
974 // 0x00 will often trigger such asserts.
976 template <typename T>
977 inline bool IsUninitialized(T data)
979 return data == UninitializedWord<T>(JitTls::GetCompiler());
982 //****************************************************************************
984 // Debug template definitions for dspPtr, dspOffset
985 // - Used to format pointer/offset values for diffable Disasm
987 template <typename T>
990 return (p == ZERO) ? ZERO : (JitTls::GetCompiler()->opts.dspDiffable ? T(0xD1FFAB1E) : p);
993 template <typename T>
996 return (o == ZERO) ? ZERO : (JitTls::GetCompiler()->opts.dspDiffable ? T(0xD1FFAB1E) : o);
999 #else // !defined(DEBUG)
1001 //****************************************************************************
1003 // Non-Debug template definitions for dspPtr, dspOffset
1004 // - This is a nop in non-Debug builds
1006 template <typename T>
1012 template <typename T>
1018 #endif // !defined(DEBUG)
1020 /*****************************************************************************/
1022 /*****************************************************************************/