initial

1 files changed, 203 insertions, 0 deletions

diff --git a/other/burneye2/codegen.h b/other/burneye2/codegen.h
new file mode 100644
index 0000000..2c9d3e1
--- /dev/null
+++ b/other/burneye2/codegen.h
@@ -0,0 +1,203 @@
+/* codegen.h - generic code generation functions, include file
+ *
+ * by scut
+ */
+
+#ifndef CODEGEN_H
+#define CODEGEN_H
+
+#include <ia32/ia32-decode.h>
+#include <ia32/ia32_opcodes.h>
+
+
+typedef struct {
+        /* overall number of instructions in the basic block
+         */
+        unsigned int            in_count;
+
+        /* .a ins1 .b ins2 .c ins3 .d ins4 ...
+         *
+         * ins[123..] are the original basic block instructions. ".a", ".b",
+         * ".c", ... are points right before the instructions. in_points[.a]
+         * (.a is zero, .b one, ..) is a list of instructions to be inserted
+         * at point .a. at this point in_points_icount[.a] instructions will
+         * be inserted.
+         */
+        ia32_instruction **     in_points;
+        unsigned int **         in_points_opcode;
+        unsigned int *          in_points_icount;
+} instr_array;
+
+
+typedef struct {
+        /* number of dataflow analysed machine instructions analysed for this
+         * profile.
+         */
+        unsigned int            lines;
+
+        /* sum of all probabilities. always greater-equal 1.0
+         */
+        double                  sum;
+
+        /* percentages (values between 0.0 and 1.0) for each register. indexed
+         * using IA32_REG_*.
+         */
+        double                  reg_use[IA32_REG_COUNT];
+} reguse_profile;
+
+
+typedef struct {
+        /* number of instructions considered
+         */
+        unsigned int            lines;
+
+        /* opnum-indexed array of percentages (values between 0.0 and 1.0) for
+         * every mnemonic
+         */
+        double                  inst_use[IA32_OPNUM_COUNT];
+} instuse_profile;
+
+
+/* codegen_operands_prob_build
+ *
+ * generate the probability table codegen_operands_prob from codegen_operands
+ * and the instruction usage profile `iprof'. this is necessary to reuse the
+ * random functions in utility.c.
+ *
+ * return in any case
+ */
+
+void
+codegen_operands_prob_build (instuse_profile *iprof);
+
+
+/* codegen_generate_instruction
+ *
+ * generate an ia32_instruction structure for `opcode' that does not clobber
+ * any memory, but only registers and eflags not used in `used_mask' (which is
+ * defined as ia32-dataflow does it). write the instruction structure to
+ * `place'. if `source_clobbered' is non-zero, the source operand will be
+ * overwritten by the instruction. if `prof' is non-NULL, registers are picked
+ * according to the profile.
+ *
+ * return NULL on failure
+ * return place on success
+ */
+
+ia32_instruction *
+codegen_generate_instruction (unsigned int opcode, unsigned int used_mask,
+        ia32_instruction *place, int source_clobbered, reguse_profile *prof);
+
+
+/* codegen_getreg
+ *
+ * generate a register number. if `clobber' is true, a register will be
+ * generated that does not touch any of the ones in `used_mask'. if `clobber'
+ * is false, a register from `used_mask' is generated. if `prof' is non-NULL,
+ * the register will be choosen by its probability. if `reg_avoid' is
+ * non-negative, the picking tries to avoid the register with number
+ * `reg_avoid'.
+ *
+ * return -1 on failure
+ * return register index on success (0-7)
+ */
+
+int
+codegen_getreg (unsigned int used_mask, int clobber, reguse_profile *prof,
+        int reg_avoid);
+
+
+/* codegen_generate_operation
+ *
+ * generate a IA32 opcode number (from ia32_opcodes.h) to be used for a new
+ * instruction. the generated opcode will not clobber any eflags used in
+ * `used_mask', which is defined as in ia32-dataflow. `source_clobbered' is
+ * overwritten with either zero or non-zero, depending on whether the source
+ * operand of the generated opcode is overwritten by the instruction. if
+ * `iprof' is non-NULL, the instructions will be picked according to the
+ * statistical distribution of `iprof'.
+ *
+ * return opcode number in any case
+ */
+
+unsigned int
+codegen_generate_operation (unsigned int used_mask, int *source_clobbered,
+        instuse_profile *iprof);
+
+
+/* codegen_reguse_profile_create
+ *
+ * create a register use profile from the function list `flist'
+ * and `flist_count', which all need to have passed a dataflow analysis.
+ *
+ * return NULL on failure
+ * return register usage profile on success
+ */
+
+reguse_profile *
+codegen_reguse_profile_create (ia32_function **flist, unsigned int flist_count);
+
+
+/* codegen_reguse_profile_print
+ *
+ * print the profile `prof' to stdout.
+ *
+ * return in any case
+ */
+
+void
+codegen_reguse_profile_print (reguse_profile *prof);
+
+
+/* codegen_instuse_profile_print
+ *
+ * print an instruction usage profile `iprof'. if `machine' is non-zero, a
+ * machine parsable format will be used.
+ *
+ * return in any case
+ */
+
+void
+codegen_instuse_profile_print (instuse_profile *iprof, int machine);
+
+
+/* codegen_instuse_profile_create
+ *
+ * create an instruction usage profile for all functions in `flist', which is
+ * `flist_count' items long.
+ *
+ * return the profile in any case
+ */
+
+instuse_profile *
+codegen_instuse_profile_create (ia32_function **flist, unsigned int flist_count);
+
+
+/* codegen_instr_array_copy
+ *
+ * create a deep copy of the instruction array `ia'.
+ *
+ * return new array on success
+ * return NULL if there was nothing to copy
+ */
+
+instr_array *
+codegen_instr_array_copy (instr_array *ia);
+
+
+/* codegen_instr_array_split
+ *
+ * split the instruction array `ia' at the `split_point'th instruction into a
+ * new array. shorten `ia' appropiatly. this is the pendant to
+ * ia32_df_bblock_split and they both act similar to a copy constructor. they
+ * are required for basic block splitting.
+ *
+ * return new instruction array (lieing directly behind `ia')
+ */
+
+instr_array *
+codegen_instr_array_split (instr_array *ia, unsigned int split_point);
+
+#endif
+
+