From 9bc20918c93d0dbc6b2def72123d3b3d8990a0c6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?V=C3=ADtor=20Santos=20Costa?= Date: Mon, 26 Jan 2015 07:34:09 +0000 Subject: [PATCH] JIT code --- H/amijit.h | 497 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 497 insertions(+) create mode 100644 H/amijit.h diff --git a/H/amijit.h b/H/amijit.h new file mode 100644 index 000000000..e06c9e5f0 --- /dev/null +++ b/H/amijit.h @@ -0,0 +1,497 @@ +/* + * amijit.h + * + * Created on: Jan 9, 2015 + * Author: vsc + */ + +#ifndef AMIJIT_H_ +#define AMIJIT_H_ + +#if YAP_JIT +/* Available LLVM (v. 3.1) Analysis Passes */ +typedef enum { + e_createAAEvalPass, //Exhaustive Alias Analysis Precision Evaluator + e_createAliasAnalysisCounterPass, //Count Alias Analysis Query Responses + e_createBasicAliasAnalysisPass, //Basic Alias Analysis (stateless AA impl) + e_createCFGOnlyPrinterPass, //Print CFG of function to 'dot' file (with no function bodies) + e_createCFGPrinterPass, //Print CFG of function to 'dot' file + e_createDbgInfoPrinterPass, //Print debug info in human readable form + e_createDomOnlyPrinterPass, //Print dominance tree of function to 'dot' file (with no function bodies) + e_createDomPrinterPass, //Print dominance tree of function to 'dot' file + e_createGlobalsModRefPass, //Simple mod/ref analysis for globals + e_createInstCountPass, //Counts the various types of Instructions + e_createIVUsersPass, //Induction Variable Users + e_createLazyValueInfoPass, //Lazy Value Information Analysis + e_createLibCallAliasAnalysisPass, //LibCall Alias Analysis + e_createLintPass, //Statically lint-checks LLVM IR + e_createLoopDependenceAnalysisPass, //Loop Dependence Analysis + e_createMemDepPrinter, //Memory Dependence Analysis + e_createModuleDebugInfoPrinterPass, //Decodes module-level debug info + e_createNoAAPass, //No Alias Analysis (always returns 'may' alias) + e_createNoPathProfileInfoPass, //No Path Profile Information + e_createNoProfileInfoPass, //No Profile Information + e_createObjCARCAliasAnalysisPass, //ObjC-ARC-Based Alias Analysis + e_createPathProfileLoaderPass, //Loads information from a path profile dump file + e_createPathProfileVerifierPass, //Verifies path profiling information + e_createPostDomOnlyPrinterPass, //Print postdominance tree of function to 'dot' file (with no function bodies) + e_createPostDomPrinterPass, //Print postdominance tree of function to 'dot' file + e_createProfileEstimatorPass, //Estimate profiling information + e_createProfileLoaderPass, //Load profile information from llvmprof.out + e_createProfileVerifierPass, //Verify profiling information + e_createRegionInfoPass, //Detect single entry single exit regions + e_createRegionOnlyPrinterPass, //Print regions of function to 'dot' file (with no function bodies) + e_createRegionPrinterPass, //Print regions of function to 'dot' file + e_createScalarEvolutionAliasAnalysisPass, //ScalarEvolution-based Alias Analysis + e_createTypeBasedAliasAnalysisPass //Type-Based Alias Analysis +} enumAnalysisPasses; + +/* Available LLVM (v. 3.1) Transform Passes */ +typedef enum{ + t_createAggressiveDCEPass, //This pass uses the SSA based Aggressive DCE algorithm + t_createArgumentPromotionPass, //Promotes "by reference" arguments to be passed by value if the number of elements passed is smaller or equal to maxElement + t_createBBVectorizePass, //A basic-block vectorization pass + t_createBlockExtractorPass, //Extracts all blocks (except those specified in the argument list) from the functions in the module + t_createBlockPlacementPass, //This pass reorders basic blocks in order to increase the number of fall-through conditional branches + t_createBreakCriticalEdgesPass, //Break all of the critical edges in the CFG by inserting a dummy basic block + t_createCFGSimplificationPass, //Merge basic blocks, eliminate unreachable blocks, simplify terminator instructions, etc... + t_createCodeGenPreparePass, //Prepares a function for instruction selection + t_createConstantMergePass, //Returns a new pass that merges duplicate global constants together into a single constant that is shared + t_createConstantPropagationPass, //A worklist driven constant propagation pass + t_createCorrelatedValuePropagationPass, //Propagate CFG-derived value information + t_createDeadArgEliminationPass, //This pass removes arguments from functions which are not used by the body of the function + t_createDeadArgHackingPass, //Same as DAE, but delete arguments of external functions as well + t_createDeadCodeEliminationPass, //This pass is more powerful than DeadInstElimination + t_createDeadInstEliminationPass, //Removes trivially dead instructions without modifying the CFG of the function + t_createDeadStoreEliminationPass, //Deletes stores that are post-dominated by must-aliased stores and are not loaded used between the stores + t_createDemoteRegisterToMemoryPass, //This pass is used to demote registers to memory references + t_createEarlyCSEPass, //This pass performs a simple and fast CSE pass over the dominator tree + t_createFunctionAttrsPass, //Discovers functions that do not access memory, or only read memory, and gives them the readnone/readonly attribute + t_createFunctionInliningPass, + t_createGlobalDCEPass, //This transform is designed to eliminate unreachable internal globals (functions or global variables) + t_createGlobalOptimizerPass, //Returns a new pass that optimizes non-address taken internal globals + t_createGVExtractionPass, //Deletes as much of the module as possible, except for the global values specified + t_createGVNPass, //Performs global value numbering and redundant load elimination cotemporaneously + t_createIndVarSimplifyPass, //Transform induction variables in a program to all use a single canonical induction variable per loop + t_createInstructionCombiningPass, //Combine instructions to form fewer, simple instructions + t_createInstructionNamerPass, //Give any unnamed non-void instructions "tmp" names + t_createInstructionSimplifierPass, //Remove redundant instructions + t_createInternalizePass, //Loops over all of the functions in the input module, internalizing all globals + t_createIPConstantPropagationPass, //Propagates constants from call sites into the bodies of functions + t_createIPSCCPPass, //Propagates constants from call sites into the bodies of functions, and keeps track of whether basic blocks are executable in the process + t_createJumpThreadingPass, //Thread control through mult-pred/multi-succ blocks where some preds always go to some succ + t_createLCSSAPass, //This pass inserts phi nodes at loop boundaries to simplify other loop optimizations + t_createLICMPass, //Loop invariant code motion and memory promotion pass + t_createLoopDeletionPass, //Performs DCE of non-infinite loops that it can prove are dead + t_createLoopExtractorPass, //Extracts all natural loops from the program into a function if it can + t_createLoopIdiomPass, //Recognizes and replaces idioms in loops + t_createLoopInstSimplifyPass, //Simplifies instructions in a loop's body + t_createLoopRotatePass, //Simple loop rotating pass + t_createLoopSimplifyPass, //Insert Pre-header blocks into the CFG for every function in the module + t_createLoopStrengthReducePass, //This pass is strength reduces GEP instructions that use a loop's canonical induction variable as one of their indices + t_createLoopUnrollPass, //Simple loop unrolling pass + t_createLoopUnswitchPass, //Simple loop unswitching pass + t_createLowerAtomicPass, //Lower atomic intrinsics to non-atomic form + t_createLowerExpectIntrinsicPass, //Removes llvm.expect intrinsics and creates "block_weights" metadata + t_createLowerInvokePass, //Converts invoke and unwind instructions to use sjlj exception handling mechanisms + t_createLowerSwitchPass, //Converts SwitchInst instructions into a sequence of chained binary branch instructions + t_createMemCpyOptPass, //Performs optimizations related to eliminating memcpy calls and/or combining multiple stores into memset's + t_createMergeFunctionsPass, //Discovers identical functions and collapses them + t_createObjCARCAPElimPass, //ObjC ARC autorelease pool elimination + t_createObjCARCContractPass, //Late ObjC ARC cleanups + t_createObjCARCExpandPass, //ObjC ARC preliminary simplifications + t_createObjCARCOptPass, //ObjC ARC optimization + t_createPartialInliningPass, //Inlines parts of functions + t_createPromoteMemoryToRegisterPass, //This pass is used to promote memory references to be register references + t_createPruneEHPass, //Return a new pass object which transforms invoke instructions into calls, if the callee can _no t_ unwind the stack + t_createReassociatePass, //This pass reassociates commutative expressions in an order that is designed to promote better constant propagation, GCSE, LICM, PRE... + t_createScalarReplAggregatesPass, //Break up alloca's of aggregates into multiple allocas if possible. + t_createSCCPPass, //Sparse conditional constant propagation + t_createSimplifyLibCallsPass, //Optimizes specific calls to specific well-known (library) functions + t_createSingleLoopExtractorPass, //Extracts one natural loop from the program into a function if it can + t_createSinkingPass, //Code Sinking + t_createStripDeadDebugInfoPass, //Removes unused symbols' debug info + t_createStripDeadPrototypesPass, //Removes any function declarations (prototypes) that are not used + t_createStripDebugDeclarePass, //Removes llvm.dbg.declare intrinsics + t_createStripNonDebugSymbolsPass, //Strips symbols from functions and modules + t_createStripSymbolsPass, //Removes symbols from functions and modules + t_createTailCallEliminationPass //Eliminates call instructions to the current function which occur immediately before return instructions +} enumTransformPasses; + +/* Enumeration for points to verify module correctness */ +typedef enum { + NOPOINT, // no point -- module will not be verified + BEFORE, // before optimize -- module will be verified before transform passes + AFTER, // after optimize -- module will be verified after transform passes + BOTH // both -- module will be verified both before and after transform passes +} enumPointToVerifiy; + +/* Enumeration for available execution modes */ +typedef enum { + JUST_INTERPRETED, + SMART_JIT, + CONTINUOUS_COMPILATION, + JUST_COMPILED +} enumExecModes; + +/* Enumerations for available parameters for frequency measurement */ +typedef enum{ + NO_FREQ, // without frequency (used on 'JUST_INTERPRETED' and 'JUST_COMPILED' modes) + COUNTER, // unity counters + TIME // unity execution times +} enumFrequencyType; + +/* Enumerations for types of clauses that can be head on traces */ +typedef enum{ + UNUSED, // not used + JUST_HOT, // enumFrequencyType associated to clause must reach threshold + HOT_AND_CALLEE, // JUST_HOT + clause must contain a callee opcode (fcall or call) + HOT_AND_GREATER, // JUST_HOT + clause size must be greater than others + HOT_AND_FEWER // JUST_HOT + clause's backtracks must be smaller than others +} enumMainClauseType; + +/* Enumerations for available llvm registers allocators */ +typedef enum{ + REG_ALLOC_BASIC, // Basic + REG_ALLOC_FAST, // Fast + REG_ALLOC_GREEDY, // Greedy + REG_ALLOC_PBQP // PBQP +} enumRegAllocator; + +#include // for 'CONTINUOUS_COMPILATION' mode +#endif /* YAP_JIT */ + +/* Enumeration for points to apply debug predicates */ +typedef enum{ + NO_PLACE = 0, // no place + ON_INTERPRETER = 1, // on interpreted opcodes + ON_PROFILED_INTERPRETER = 2, // on profiled opcodes + ON_NATIVE = 4 // on native code +} enumPlace; + +/* This struct is used by debug predicates -- + usually associated to yaam opcode, basic blocks or clauses */ +typedef struct printt_struc { + Int print; // Should I print? + CELL msg_before; // If I print, what message should come before? + CELL msg_after; // If I print, what message should come after? +} PrinttStruc; + +/* This struct represents our experimental environment for YAP */ +typedef struct environment { +#if YAP_JIT + // struct for analysis predicates -- all fields are modified by analysis predicates (JIT_AnalysisPreds.c) + struct { + CELL outfile; // Where will analysis results be printed? + Int stats_enabled; // Should llvm stats be printed on 'shutdown_llvm()'? + Int time_pass_enabled; // Should llvm time passes be printed on 'shutdown_llvm()'? + enumPointToVerifiy pointtoverifymodule; // What point of code will llvm modules be verified? + COUNT n; // Number of elements on 'act_an' + enumAnalysisPasses *act_an; // List of analysis passes + } analysis_struc; + + // struct for transform predicates -- all fields are modified by transform predicates (JIT_TransformPreds.c) + struct { + Int optlevel; // Optimization level -- 'act_tr' only will be used if 'optlevel' is '-1' + COUNT n; // Number of elements on 'act_tr' + enumTransformPasses *act_tr; // List of transform passes + struct { + CELL arg_promotion_max_elements; // Max elements on 'Argument Promotion Pass' + CELL strip_symbols_pass_type; // Argument for 'Strip Symbols Pass' -- if true, only debugging information is removed from the module + CELL scalar_replace_aggregates_threshold; // Threshold for 'Scalar Repl Aggregates Pass' + CELL loop_unswitch_optimize_for_size; // Argument for 'Loop Unswitch Pass' -- Should I optimize for size? + CELL loop_unroll_threshold; // Threshold for 'Loop Unroll Pass' + CELL inline_threshold; // Threshold for 'Function Inlining Pass' + } opt_args; + Int unit_at_time_enabled; // Should I enable IPO? + Int simplify_libcalls_enabled; // Should I simplify libcalls? + struct { + Int enabled; // Should I enable link-time optimizations? + CELL internalize; // Should I run 'Internalize Pass' on link-time optimization? + CELL runinliner; // Should I run 'Inline Pass' on link-time optimization? + } link_time_opt; + } transform_struc; + + // struct for codegen predicates -- all fields are modified by codegen predicates (JIT_CodegenPreds.c) + struct { + struct { + Int noframepointerelim; // Should I use frame pointer elimination opt? + Int lessprecisefpmadoption; // Should I allow to generate multiply add if the result is "less precise"? + Int noexcessfpprecision; // Should I enable excess fp precision? + Int unsafefpmath; // Should I allow to produce results that are "less precise" than IEEE allows? + Int honorsigndependentroundingfpmathoption; // Which rounding mode should I use? + Int usesoftfloat; // Should I use libcalls or FP instructions to treat floating point libraries? + Int jitexceptionhandling; // Should JIT emit exception handling info? + Int jitemitdebuginfo; // Should JIT emit debug information? + Int jitemitdebuginfotodisk; // Should JIT write debug information to disk? + Int guaranteedtailcallopt; // Should I perform tail call optimization on calls which use fastcc calling convention? + Int disabletailcalls; // Should I use tail calls? + Int fastisel; // Should I use 'fast-path instruction selection' to reduce compilation time? If 'yes' native code won't have best quality + Int floatabitype; /* 0 = Default, 1 = Soft, 2 = Hard */ + } struc_targetopt; + struct { + Int engineoptlevel; /* 0 = None, 1 = Less, 2 = Default, 3 = Agressive */ + Int relocmodel; /* 0 = Default, 1 = Static, 2 = PIC, 3 = DynamicNoPIC */ + Int codemodel; /* 0 = Default, 1 = JITDefault, 2 = Small, 3 = Kernel, 4 = Medium, 5 = Large */ + Int usemcjit; // Should I use MC-JIT implementation (experimental)? + enumRegAllocator regallocator; // Active register allocator (predicate register_allocator/1) + } struc_enginebuilder; + } codegen_struc; + + // struct for configuration predicates -- all fields are modified by configuration predicates (JIT_ConfigPreds.c) + struct { + enumExecModes execution_mode; // Active execution mode + enumFrequencyType frequency_type; // Active frequency type + Float frequency_bound; // Bound to become clauses as hot + Float profiling_startp; // Bound to init monitoring and trace building + enumMainClauseType mainclause_ty; // Types of clauses that can be head on traces + COUNT ncores; // Number of cores on processor -- used to determine default 'compilation_threads' (compilation_threads = ncores - 1) + COUNT compilation_threads; // Number of compilation threads (used only if 'execution_mode' is 'CONTINUOUS_COMPILATION') + pthread_t* threaded_compiler_threads; // List of threads (size = 'compilation_threads'). Used by function 'pthread_create'. Used on 'CONTINUOUS_COMPILATION' mode + CELL* posthreads; // Used to determine which threads are free/busy + Int torecompile; // Should I recompile traces? + Int current_displacement; // Jump displacement to run yaam opcodes on absmi. Zero is the default value and will make standard yaam opcodes are executed. 'TOTAL_OF_OPCODES' is the value after any clause become critical and will make 'traced_' yaam opcodes are executed. + COUNT TOTAL_OF_OPCODES; // Total of yaam opcodes. I must determine this dynamically due to several '#define' statements. Used to determine 'current_displacement' after any clause become critical. + Int useonlypi; // Execute only 'traced_' yaam opcodes. Don't compile. WARNING: if you enable this field (predicate only_profiled_interpreter/0), the system performance will decrease considerably. Use only to determine the actual cost of running such opcodes. + } config_struc; + +#if YAP_STAT_PREDS + // struct for statistic predicates -- all fields are modified by statistic predicates (JIT_StatisticPreds.c) + struct { + int papi_initialized; // Was PAPI initialized? Used on predicate 'statistics_jit/0' -- if 1, PAPI results will be emitted + int papi_eventset; // PAPI event set + long long *papi_values; // List of collected performance counter values + short *papi_valid_values; // List of performance counters that will be collected + int papi_event_type; // Type of event that will be collected -- 'papi_event_type' involves what performance counters will be within 'papi_valid_values' + } stats_struc; +#endif +#endif /* YAP_JIT */ + +#if YAP_DBG_PREDS + // struct for debug predicates -- all fields are modified by debug predicates (JIT_DebugPreds.c) + struct { + /* Here, one 'PrinttStruc' for each yaam opcode on 'YapAppliedOpcodes.h' */ + #define OPCODE(OP,TYPE) \ + PrinttStruc pyaam_##OP; + #include "YapAppliedOpcodes.h" + #undef OPCODE + + /* Here, one 'PrinttStruc' for each basic block on 'AppliedBasicBlocks.h' */ + #define BBLOCK(BB) \ + PrinttStruc pbbs_##BB; + #include "Yap_AppliedBasicBlocks.h" + #undef BBLOCK + + /* This 'PrinttStruc' inform system whether head-clauses on traces should be printed */ + PrinttStruc pmainclause_on_head; + + /* Fields to treat intermediate code */ + struct{ + Int print_to_std; // Should intermediate code be printed on std (stdout, stderr)? Default:: print_to_std = 0 (don't print to stdout nor stderr) + Int print_to_file; // Should intermediate code be printed on file? Default:: print_to_file = 0 (don't print to file) + CELL std_name; // if 'print_to_std' = 'yes', where should intermediate code be printed? + CELL file_name; // if 'print_to_file' = 'yes', what file should intermediate code be printed? + } pprint_intermediate; + + /* Fields to treat llva code */ + struct { + Int print_llva_before; // Should llva code be printed before optimizing module? + Int print_llva_after; // Shoud llva code be printed after optimizing module? + } pprint_llva; + + /* Fields for predicate print_me/2 */ + struct { + CELL interpreted_backtrack; // msg to print when backtrack on standard yaam opcodes occur + CELL profiled_interpreted_backtrack; // msg to print when backtrack on 'traced_' yaam opcodes occur + CELL native_backtrack; // msg to print when backtrack on native code occur + CELL interpreted_treat_heap; // msg to print when heap is treated on interpreter (standard and 'traced_' yaam opcodes) + CELL native_treat_heap; // msg to print when heap is treated on native code + CELL interpreted_treat_trail; // msg to print when trail is treated on interpreter (standard and 'traced_' yaam opcodes) + CELL native_treat_trail; // msg to print when trail is treated on native code + CELL criticals; // msg to print when any clause becomes critical + CELL at_compilation; // msg to print before compilation + CELL at_recompilation; // msg to print before recompilation + CELL nativerun_init; // msg to print when native code is about to be run + CELL nativerun_exit_by_success; // msg to print when native code exits by success, ie., basic block nonexistent in native code (allows rebuilding and recompilation of traces) + CELL nativerun_exit_by_fail; // msg to print when native code exits byfail, ie., exits to treat trail or heap (don't allow rebuilding and recompilation of traces) + } pprint_me; + + /* Messages on all predicates */ + struct { + Int info_msgs; // Should I allow info messages? + Int success_msgs; // Should I allow success messages? + Int warning_msgs; // Should I allow warning messages? + Int error_msgs; // Should I allow error messages? + } act_predicate_msgs; + + /* Actions on all predicates */ + struct { + Int exit_on_warning; // Should I exit when any warning occur? + Int disable_on_warning; // Shouldn't I adjust appropriate values when any warning occur (implies 'exit_on_warning' = 'false') + Int exit_on_error; // Should I exit when any error occur? + } act_predicate_actions; + } debug_struc; +#endif +} Environment; + +#if YAP_JIT +/* Enumeration for types of basic blocks -- used on trace construction */ +typedef enum { + NONE, // untyped + SIMPLE_ENTRY, // first basic block of any yaam opcode + SIMPLE, // any other basic block of any yaam opcode + CONDITIONAL_HEADER, // basic block of any 'if' statement of any yaam opcode + MULTIPLE_DESTINY // basic block of many destinations (elementary block). Returns from native code to interpreter always will occur here +} BlockTy; + +/* Struct to represent individual basic blocks within traces */ +typedef struct blocks_context { + union { + /* Fields for SIMPLE_ENTRY blocks */ + struct { + UInt id; // block identifier (Yap_BasicBlocks.h) + char *label_entry; // entry label -- destinations of jumps from others 'SIMPLE_ENTRY' or 'SIMPLE' blocks + char *label_destiny; // destiny label -- where should I jump after I run? + } eb; + + /* Fields for SIMPLE blocks */ + struct { + UInt id; // block identifier (Yap_BasicBlocks.h) + char *label_destiny; // destiny label -- where should I jump after I run? + } sb; + + /* Fields for CONDITIONAL_HEADER blocks */ + struct { + char *exp; // expression of 'if' statement + struct blocks_context *_if; // destination if 'exp' is true + struct blocks_context *_else; // destination if 'exp' is false + } kb; + + /* Fields for MULTIPLE_DESTINY blocks */ + struct { + UInt id; // block identifier (Yap_BasicBlocks.h) + COUNT nfaillabels; // number of destinations caused by backtrack on native code + struct { + UInt *p; + char **labels; + } faildestiny; // destinations caused by backtrack on native code + COUNT ndest; // number of destinations that not be backtrack + struct { + UInt *p; + char **labels; + } destiny; // destinations that not be backtrack + } mdb; + + /* Fields for untyped blocks */ + struct { + CELL header; // just for aiding after treating 'CONDITIONAL_HEADER' blocks + } xb; + } u; + BlockTy blockty; // Basic block type + CELL thisp; // Value of PREG. Inside traces, basic blocks are only different from each other if 'id' and 'blockty' are different + CELL prev; // Previous basic block + CELL next; // Next basic block +} BlocksContext; + +/* Struct to represent fully traces */ +typedef struct trace_context { + COUNT n; // number of basic blocks + CELL tracesize; // For statistics... list of size (bytes) of each trace + BlocksContext *bc; // basic blocks context +} TraceContext; + +/* Struct to represent Intermediatecode Area */ +typedef struct intermediatecode_context { + COUNT n; // Total of traces stored + struct { + TraceContext** t; // List of pointers to traces -- total of 'n' + COUNT* ok; // List of traces ok (traces constructed and compiled at least once) + COUNT* isactive; // List of active traces (traces under construction). Initialized to zero + BlocksContext** lastblock; // List of last block added on each trace +#if YAP_STAT_PREDS + double* profiling_time; // For statistics... list of profiling time of each trace +#endif + } area; +} IntermediatecodeContext; + +/* Struct to represent Nativecode Area */ +typedef struct native_context { + COUNT n; // Total of traces compiled (is not necessarily equal to 'IntermediatecodeContext.n') + struct { + void** p; // List of pointers to compiled codes -- total of 'n' + COUNT* ok; // List of compiled codes ok (traces constructed and compiled at least once) + CELL* pc; // List of first heads of each compiled code +#if YAP_STAT_PREDS + COUNT *nrecomp; // For statistics... number of recompilations of each compiled code (max '1' if recompilation is disabled) + double **compilation_time; // For statistics... list of compilation time of each compiled code on each recompilation + CELL **native_size_bytes; // For statistics... list of native size (bytes) of each compiled code on each recompilation + CELL **trace_size_bytes; // For statistics... list of trace size (bytes) of each trace on each recompilation +#endif + } area; +#if YAP_STAT_PREDS + COUNT *runs; // List of calls of each compiled code + double *t_runs; // List of execution time of each compiled code + COUNT *success; // List of exit by success of each compiled code +#endif +} NativeContext; + +/* + * Control flags for managing intermediate code * + * from traces stored on Intermediatecode Area * + * Intermediatecode Area stores traces represented as * + * basic blocks sequence * +*/ +typedef struct control_flags_context { + COUNT nemited; + char** emited_blocks; + short emit; + short leastonce; + char* clabel; + COUNT labelidx; + COUNT printlabel; + char** entries; + COUNT nentries; +} ControlFlagsContext; + + +/* Struct associated to 'jit_handler' opcode */ +typedef struct jit_handl_context { + /* Main yaam opcode features -- used by predicate 'main_clause_ty/1' */ + struct { + CELL isground; // Does clause whose head is this 'jit_handler' have calls ('fcall' or 'call' opcode)? If 'yes', isground is '0'. Used when 'main_clause_ty(hot_and_callee)' + CELL clausesize; // Is clause whose head is this 'jit_handler' greater than other clauses? Used when ''main_clause_ty(hot_and_greater)' + CELL backtrack_counter; // Does clause whose head is this 'jit_handler' have fewer backtracks on history than other clauses? Used when ''main_clause_ty(hot_and_fewer)' + } mf; + + /* Frequency Instrumenters -- only one is used */ + struct { + union { + COUNT c; // counter + CELL t; // time + } bcst; // balance, counter, crossover, time + } fi; + + /* Reverse pointers to code areas ('Intermediatecode Area' and 'Native Area') */ + struct { + COUNT taddress; // intermediatecode area + COUNT naddress; // native area + } caa; + + /* Fields for aiding trace construction and compilation */ + struct { + char *cmd; // Argument to program 'echo' (called by fork on JIT_Compiler.cpp). Its value is C code that represent traces that will be compiled. Its value is freed after compilation. + ControlFlagsContext* cf; // Pointer to ControlFlagsContext. Just used here. + } tcc; + + /* Fields for managing JIT -- recompilation and threads */ + struct { + CELL used_thread; + CELL torecomp; + }jitman; +} JitHandlContext; +#endif /* YAP_JIT */ + + + + +#endif /* _AMIJIT_H_ */