502 lines
27 KiB
C
502 lines
27 KiB
C
/*
|
|
* 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 <pthread.h> // for 'CONTINUOUS_COMPILATION' mode
|
|
|
|
/* 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 {
|
|
// 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
|
|
|
|
#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;
|
|
|
|
/* Enumeration for types of basic blocks -- used on trace construction */
|
|
typedef enum block_try {
|
|
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;
|
|
|
|
extern void **Yap_ABSMI_ControlLabels;
|
|
|
|
extern Environment *Yap_ExpEnvP;
|
|
|
|
#define ExpEnv (*Yap_ExpEnvP)
|
|
|
|
#endif /* YAP_JIT */
|
|
|
|
|
|
|
|
#endif /* _AMIJIT_H_ */
|