rabbitizer 1.9.0

MIPS instruction decoder
Documentation 
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
145

/* SPDX-FileCopyrightText: © 2022-2024 Decompollaborate */
/* SPDX-License-Identifier: MIT */

#include "analysis/RabbitizerTrackedRegisterState.h"

#include <assert.h>

#include "common/Utils.h"
#include "instructions/RabbitizerRegister.h"

void RabbitizerTrackedRegisterState_init(RabbitizerTrackedRegisterState *self, int registerNum) {
    self->registerNum = registerNum;

    self->hasLuiValue = false;
    self->luiOffset = 0;
    self->luiSetOnBranchLikely = false;

    self->hasGpGot = false;
    self->gpGotOffset = 0;

    self->hasLoValue = false;
    self->loOffset = 0;
    self->dereferenced = false;
    self->dereferenceOffset = 0;

    self->value = 0;
}

void RabbitizerTrackedRegisterState_destroy(UNUSED RabbitizerTrackedRegisterState *self) {
}

void RabbitizerTrackedRegisterState_clear(RabbitizerTrackedRegisterState *self) {
    self->hasLuiValue = false;
    self->luiOffset = 0;
    self->luiSetOnBranchLikely = false;

    self->hasGpGot = false;
    self->gpGotOffset = 0;

    self->hasLoValue = false;
    self->loOffset = 0;
    self->dereferenced = false;
    self->dereferenceOffset = 0;
    self->value = 0;
}

void RabbitizerTrackedRegisterState_clearHi(RabbitizerTrackedRegisterState *self) {
    self->hasLuiValue = false;
    self->luiOffset = 0;
    self->luiSetOnBranchLikely = false;
}

void RabbitizerTrackedRegisterState_clearGp(RabbitizerTrackedRegisterState *self) {
    self->hasGpGot = false;
    self->gpGotOffset = 0;
}

void RabbitizerTrackedRegisterState_clearLo(RabbitizerTrackedRegisterState *self) {
    self->hasLoValue = false;
    self->loOffset = 0;
    self->dereferenced = false;
    self->dereferenceOffset = 0;
}

void RabbitizerTrackedRegisterState_copyState(RabbitizerTrackedRegisterState *self,
                                              const RabbitizerTrackedRegisterState *other) {
    self->hasLuiValue = other->hasLuiValue;
    self->luiOffset = other->luiOffset;
    self->luiSetOnBranchLikely = other->luiSetOnBranchLikely;

    self->hasGpGot = other->hasGpGot;
    self->gpGotOffset = other->gpGotOffset;

    self->hasLoValue = other->hasLoValue;
    self->loOffset = other->loOffset;
    self->dereferenced = other->dereferenced;
    self->dereferenceOffset = other->dereferenceOffset;

    self->value = other->value;
}

void RabbitizerTrackedRegisterState_setHi(RabbitizerTrackedRegisterState *self, uint32_t value, int offset) {
    assert(!self->hasGpGot);

    self->hasLuiValue = true;
    self->luiOffset = offset;
    self->value = value << 16;
}

void RabbitizerTrackedRegisterState_setGpLoad(RabbitizerTrackedRegisterState *self, uint32_t value, int offset) {
    assert(!self->hasLuiValue);

    self->hasGpGot = true;
    self->gpGotOffset = offset;
    self->value = value;
}

void RabbitizerTrackedRegisterState_setLo(RabbitizerTrackedRegisterState *self, uint32_t value, int offset) {
    self->value = value;
    self->loOffset = offset;
    self->hasLoValue = true;
    self->dereferenced = false;
    self->dereferenceOffset = 0;
}

void RabbitizerTrackedRegisterState_deref(RabbitizerTrackedRegisterState *self, int offset) {
    self->dereferenced = true;
    self->dereferenceOffset = offset;
}

void RabbitizerTrackedRegisterState_dereferenceState(RabbitizerTrackedRegisterState *self,
                                                     const RabbitizerTrackedRegisterState *other, int offset) {
    assert(other->hasLoValue);
    assert(!other->dereferenced);

    RabbitizerTrackedRegisterState_copyState(self, other);
    RabbitizerTrackedRegisterState_deref(self, offset);
}

bool RabbitizerTrackedRegisterState_hasAnyValue(const RabbitizerTrackedRegisterState *self) {
    return self->hasLuiValue || self->hasLoValue || self->hasGpGot;
}

bool RabbitizerTrackedRegisterState_wasSetInCurrentOffset(const RabbitizerTrackedRegisterState *self, int offset) {
    return self->loOffset == offset || self->dereferenceOffset == offset;
}

void RabbitizerTrackedRegisterState_fprint(const RabbitizerTrackedRegisterState *self, FILE *outFile) {
    fprintf(outFile, "TrackedRegisterState(%i / %s)\n", self->registerNum,
            RabbitizerRegister_getNameGpr(self->registerNum));

    fprintf(outFile, "    hasLuiValue: %s\n", self->hasLuiValue ? "true" : "false");
    fprintf(outFile, "    luiOffset: 0x%X\n", self->luiOffset);
    fprintf(outFile, "    luiSetOnBranchLikely: %s\n", self->luiSetOnBranchLikely ? "true" : "false");

    fprintf(outFile, "    hasGpGot: %s\n", self->hasGpGot ? "true" : "false");
    fprintf(outFile, "    gpGotOffset: 0x%X\n", self->gpGotOffset);

    fprintf(outFile, "    hasLoValue: %s\n", self->hasLoValue ? "true" : "false");
    fprintf(outFile, "    loOffset: %X\n", self->loOffset);
    fprintf(outFile, "    dereferenced: %s\n", self->dereferenced ? "true" : "false");
    fprintf(outFile, "    dereferenceOffset: %X\n", self->dereferenceOffset);

    fprintf(outFile, "    value: %X\n", self->value);
}