ConstantPropagation_separate_Example_Version.rls

@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
true("true"^^xsd:boolean).


% this simple implementation does NOT consider the control flow graph
% i.e. if (){
%           x=1;} 
%       else{
%           x=2;} 
%       y=x; 
% will lead to inconsistencies in the calculation
% thus it is insufficient for real world examples

% dive into doop-syntax:
% the instrucion-id (?ins) is a unique identifier for each line of intermediate code (IR)
% everything that happens on one IR-line, will be linked with the same instruction-id
% it may look like this: "<Example: void main(java.lang.String[])>/assign/4"
% where "<Example: void main(java.lang.String[])>/" is the function signature
% "assign/" means it is an assignment (i.e. a=b;), and "4" is the line number of the statement


%loaded files from doop:

% AssignNumConstant:        contains all variables that hold a constant value (i.e. a = 1) -> this is the base for this analysis
@import AssignNumConstant :- tsv { resource="data/AssignNumConstant.tsv.gz",format=(string, int, int, string, string)}.


% AssignLocal:              holds assignments of type a = b. 
% which only holds static assignments (assignments that include the string "phi-assign" are dynamically and have been removed)
@import AssignLocal :- tsv { resource="data/AssignLocal.tsv.gz",format=(string, int, string, string, string)}.


% OperatorAt:               links an instruction-id of a unary or binary expression to its operator
%                           most common operators: (~, +, -, *, /, >=, <=, ==, <<, !=, >, len, <, %, ^, cmp, &, cmpl, cmpg, >>>, >>, |)
@import OperatorAt :- tsv { resource="data/OperatorAt.tsv.gz",format=(string,string)}.


% AssignUnop:               holds the instruction-id and variable that is getting assigned by a unary expression
@import AssignUnop :- tsv { resource="data/AssignUnop.tsv.gz",format=(string, int, string, string)}.


% AssignBinop:              holds the instruction-id and the variable that is getting assigned by a binary expression
@import AssignBinop :- tsv { resource="data/AssignBinop.tsv.gz",format=(string, int, string, string)}.


% AssignOperFrom:           links an instruction-id of a unary or binary expression, to the VARIABLE(S) that are used    
%                           (i.e. a = b + c, will have two entries in AssignOperFrom)
@import AssignOperFrom :- tsv { resource="data/AssignOperFrom.tsv.gz",format=(string, int, string)}.


% AssignOperFromConstant:   links an instruction-id of a unary or binary expression to the CONSTANT(S) used 
%                           (i.e. a = b + 2, will have one entries in AssignOperFromConstant)
@import AssignOperFromConstant :- tsv { resource="data/AssignOperFromConstant.tsv.gz",format=(string, int, int)}.

% Implementation:
% IntegerConstant contains all constants (given & computed)
% it is initialized with all constants that are supplied by doop in AssignNumConstant (i.e. a = 2;)
% ConstFolding will contain all variables and values where constant folding & propagation was successfull
% the doop relations AssignUnop & AssignBinop ONLY contain the instruction-id and the assigned variable 
% -> we need to manually check, if the expression consists of constants (a =  1 + 2;) variables (a = b + c;) or both (a = b + 2;)
%   -> 2 cases for unary expressions:   (- const), (- var)                           
%   -> 3 cases each for binary expressions (+,*): (var + var), (const + const), (const + var)-> order of var & const is irrelevant
%   -> 4 cases each for binary expressions (-, /): (var - var), (const - const), (const - var), (var - const) -> order of var & const is relevant 


% Initialize IntegerConstant with all constants from AssignNumConstant
IntegerConstant(?var, ?val,?meth) :-
    AssignNumConstant(_, _, ?val, ?var, ?meth).

PhiAssignLocal(?ins, ?var_from, ?var_to, ?meth):-
    AssignLocal(?ins, _, ?var_from, ?var_to, ?meth),
    true(CONTAINS(?ins,"phi-assign")).

 %Assignment without Operator (i.e.  a  = b)
IntegerConstant(?var_to, ?val, ?meth),
ConstFolding(?ins,?var_to, ?val,  ?meth) :-
    AssignLocal(?ins, _, ?var_from, ?var_to, ?meth),
    ~PhiAssignLocal(?ins, ?var_from, ?var_to, ?meth),    
    IntegerConstant(?var_from, ?val, ?meth).



% Unary-Negation: "-" is translated to "~" in OperatorAt

IntegerConstant(?var, 0 - ?val1, ?meth),
ConstFolding(?ins,?var, 0 - ?val1,?meth) :-
    AssignUnop(?ins,_, ?var, ?meth),
    OperatorAt(?ins,"~"),
    AssignOperFrom(?ins, _, ?var1),
    IntegerConstant(?var1, ?val1, ?meth).

IntegerConstant(?var, 0 - ?val1, ?meth),
ConstFolding(?ins,?var, 0 - ?val1,  ?meth) :-
    AssignUnop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "~",
    AssignOperFromConstant(?ins, _, ?val1).


% Addition
IntegerConstant(?var, ?val1 + ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 + ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "+",
    AssignOperFromConstant(?ins, _, ?val1),
    AssignOperFrom(?ins, _, ?var2),
    IntegerConstant(?var2, ?val2,?meth).


IntegerConstant(?var, ?val1 + ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 + ?val2, ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "+",
    AssignOperFromConstant(?ins, ?pos1, ?val1),
    AssignOperFromConstant(?ins, ?pos2, ?val2),
    ?pos1 < ?pos2.

IntegerConstant(?var, ?val1 + ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 + ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "+",
    AssignOperFrom(?ins, ?pos1, ?var1),
    AssignOperFrom(?ins, ?pos2, ?var2),
    ?pos1 < ?pos2,
    IntegerConstant(?var1, ?val1, ?meth),
    IntegerConstant(?var2, ?val2,?meth).



% Subtraction

IntegerConstant(?var, ?val1 - ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 - ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "-",
    AssignOperFromConstant(?ins, ?pos1, ?val1),
    AssignOperFrom(?ins, ?pos2, ?var2),
    ?pos1 < ?pos2, 
    IntegerConstant(?var2, ?val2,?meth).

IntegerConstant(?var, ?val1 - ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 - ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "-",
    AssignOperFrom(?ins, ?pos1, ?var1),
    IntegerConstant(?var1, ?val1, ?meth),
    AssignOperFromConstant(?ins, ?pos2, ?val2),
    ?pos1 < ?pos2.

IntegerConstant(?var, ?val1 - ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 - ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "-",
    AssignOperFromConstant(?ins, ?pos1, ?val1),
    AssignOperFromConstant(?ins, ?pos2, ?val2),
    ?pos1 < ?pos2.

IntegerConstant(?var, ?val1 - ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 - ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "-",
    AssignOperFrom(?ins, ?pos1, ?var1),
    AssignOperFrom(?ins, ?pos2, ?var2),
    ?pos1 < ?pos2,
    IntegerConstant(?var1, ?val1, ?meth),
    IntegerConstant(?var2, ?val2,?meth).



% Multiplication

IntegerConstant(?var, ?val1 * ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 * ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "*",
    AssignOperFromConstant(?ins, _, ?val1),
    AssignOperFrom(?ins, _, ?var2),
    IntegerConstant(?var2, ?val2,?meth).

IntegerConstant( ?var, ?val1 * ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 * ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "*",
    AssignOperFromConstant(?ins, ?pos1, ?val1),
    AssignOperFromConstant(?ins, ?pos2, ?val2),
    ?pos1 < ?pos2.

IntegerConstant(?var, ?val1 * ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 * ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "*",
    AssignOperFrom(?ins, ?pos1, ?var1),
    AssignOperFrom(?ins, ?pos2, ?var2),
    ?pos1 < ?pos2,
    IntegerConstant(?var1, ?val1, ?meth),
    IntegerConstant(?var2, ?val2,?meth).

% Division

IntegerConstant(?var, ?val1 / ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 / ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "/",
    AssignOperFromConstant(?ins, ?pos1, ?val1),
    AssignOperFrom(?ins, ?pos2, ?var2),
    ?pos1 < ?pos2, 
    IntegerConstant(?var2, ?val2,?meth).

IntegerConstant(?var, ?val1 / ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 / ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "/",
    AssignOperFrom(?ins, ?pos1, ?var1),
    IntegerConstant(?var1, ?val1, ?meth),
    AssignOperFromConstant(?ins, ?pos2, ?val2),
    ?pos1 < ?pos2.

IntegerConstant(?var, ?val1 / ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 / ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "/",
    AssignOperFromConstant(?ins, ?pos1, ?val1),
    AssignOperFromConstant(?ins, ?pos2, ?val2),
    ?pos1 < ?pos2.

IntegerConstant(?var, ?val1 / ?val2, ?meth),
ConstFolding(?ins,?var, ?val1 / ?val2,  ?meth) :-
    AssignBinop(?ins,_, ?var, ?meth),
    OperatorAt(?ins, ?op),
    ?op = "/",
    AssignOperFrom(?ins, ?pos1, ?var1),
    AssignOperFrom(?ins, ?pos2, ?var2),
    ?pos1 < ?pos2,
    IntegerConstant(?var1, ?val1, ?meth),
    IntegerConstant(?var2, ?val2,?meth).

@export ConstFolding :- tsv{resource="ConstFolding.tsv",format=(string,string,int,string)}.
@export IntegerConstant :- tsv{resource="IntegerConstant.tsv",format=(string,int,string)}.