osprey 0.4.4

Gluon bindings for Falcon
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// This script finds direct branches in a binary

let array = import! "std/array.glu"
let falcon = import! "scripts/falcon.glu"
let function = import! "std/function.glu"
let io = import! "std/io.glu"
let list = import! "std/list.glu"
let types = import! "std/types.glu"

let { il, loader } = falcon
let { Expression, Operation } = falcon.types
let { List } = list
let { (|>) } = function
let {(++)} = import! "std/string.glu"
let { Option, Bool } = types

let append l m =
    match l with
    | Nil -> m
    | Cons hd tl -> Cons hd (append tl m)

let flatten l =
    match l with
    | Nil -> Nil
    | Cons hd tl -> append hd (flatten tl)

let filter f l =
    match l with
    | Nil -> Nil
    | Cons hd tl -> 
        if f hd then
            Cons hd (filter f tl)
        else
            filter f tl

let unwrap option = 
    match option with
    | Some x -> x
    | None -> error "unwrapped option with value None"

let is_some option =
    match option with
    | Some _ -> True
    | None -> False

let foldl f x xs =
    match xs with
    | Cons y ys -> foldl f (f x y) ys
    | Nil -> x

let map f l =
    match l with
    | Nil -> Nil
    | Cons hd tl -> Cons (f hd) (map f tl)


let all_constants e : IlExpression -> Bool =
    match il.expression.match_ e with
    | Scalar s -> False
    | Constant c -> True
    | Add l r -> (all_constants l) && (all_constants r)
    | Sub l r -> (all_constants l) && (all_constants r)
    | Mul l r -> (all_constants l) && (all_constants r)
    | Divu l r -> (all_constants l) && (all_constants r)
    | Modu l r -> (all_constants l) && (all_constants r)
    | Divs l r -> (all_constants l) && (all_constants r)
    | Mods l r -> (all_constants l) && (all_constants r)
    | And l r -> (all_constants l) && (all_constants r)
    | Or l r -> (all_constants l) && (all_constants r)
    | Xor l r -> (all_constants l) && (all_constants r)
    | Shl l r -> (all_constants l) && (all_constants r)
    | Shr l r -> (all_constants l) && (all_constants r)
    | Cmpeq l r -> (all_constants l) && (all_constants r)
    | Cmpneq l r -> (all_constants l) && (all_constants r)
    | Cmpltu l r -> (all_constants l) && (all_constants r)
    | Cmplts l r -> (all_constants l) && (all_constants r)
    | Zext _ src -> (all_constants src)
    | Sext _ src -> (all_constants src)
    | Trun _ src -> (all_constants src)


let filename =
    match falcon.env "FILENAME" with
    | Some filename -> filename
    | None -> error "Could not get filename"

let function_name = 
    match falcon.env "FUNCTION_NAME" with
    | Some function_name -> function_name
    | None -> "Could not get function name"


let brc_is_direct instruction : IlInstruction -> Bool =
    match il.instruction.operation instruction |> il.operation.match_ with
    | Branch target -> all_constants target
    | _ -> error "brc_is_direct given non-brc instruction"


let find_brcs function : IlFunction -> List IlInstruction =
    let is_brc i =
        match il.operation.match_ (il.instruction.operation i) with
        | Branch target -> Some i
        | _ -> None

    let control_flow_graph = il.function.control_flow_graph function
    let blocks = il.control_flow_graph.blocks control_flow_graph |> list.of
    let instructions = map il.block.instructions blocks |> map list.of |> flatten
    map is_brc instructions |> filter is_some |> map unwrap


let find_function binary function_name =
    let find functions i name =
        if i == (array.len functions) then
            None
        else
            let function_entry = array.index functions i
            match loader.function_entry.name function_entry with
            | Some entry_name ->
                if entry_name == name then
                    Some function_entry
                else
                    find functions (i + 1) name
            | None -> find functions (i + 1) name
    find (loader.loader.function_entries binary) 0 function_name


let binary =
    match loader.loader.from_file filename with
    | Some x -> x
    | None -> error "Failed to load binary"

let function_entry =
    match find_function binary function_name with
    | Some function_entry -> function_entry
    | None -> error "failed to find function entry"
    
let function = loader.function_entry.address function_entry |> loader.loader.function binary

let brcs = find_brcs function |> filter brc_is_direct
let strings = map il.instruction.str brcs

let lines = foldl (\ l r -> l ++ "\n" ++ r) "" strings

falcon.println lines