rabbitizer 1.16.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
146
147
148
149
150
151
152
153
154

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

#include "common/Utils.h"

#include <stdbool.h>
#include <string.h>

int32_t RabbitizerUtils_From2Complement(uint32_t number, int bits) {
    bool isNegative = number & (1ULL << (bits - 1));

    if (isNegative) {
        return -((~number + 1) & ((1ULL << bits) - 1));
    }

    return number;
}

size_t RabbitizerUtils_CharFill(char *dst, int count, char fillchar) {
    if (count <= 0) {
        return 0;
    }

    memset(dst, fillchar, count);

    return count;
}

size_t RabbitizerUtils_escapeString(char *dst, size_t dstSize, const char *src, size_t srcSize) {
    size_t srcPos = 0;
    size_t dstpos = 0;

    for (; srcPos < srcSize && dstpos < dstSize; srcPos++, src++) {
        // The cases of this switch are sorted by ASCII order
        switch (*src) {
            case '\a':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, 'a');
                break;

            case '\t':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, 't');
                break;

            case '\n':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, 'n');
                break;

            case '\f':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, 'f');
                break;

            case '\r':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, 'r');
                break;

            case '"':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '"');
                break;

            case '\\':
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, '\\');
                break;

            default:
                RABUTILS_BUFFER_WRITE_CHAR(dst, dstpos, *src);
                break;
        }
    }

    return dstpos;
}

uint32_t RabbitizerUtils_floatRepr_32From16(uint16_t arg) {
    // IEEE754 16-bit floats are encoded in 16 bits as follows:
    // Sign bit: 1 bit (bit 15)
    // Encoded exponent: 5 bits (bits 10 ~ 15)
    // Fraction/Mantissa: 10 bits (bits 0 ~ 9)

    uint32_t ret;
    int32_t sign;
    int32_t encodedExponent;
    int32_t realExponent;
    bool mantissaIsZero;

    // arg.d = a;

    ret = 0;

    sign = arg >> 15;

    // If parameter is zero, then return zero
    if ((arg & ~(1ULL << 15)) == 0) {
        // Preserve the sign
        ret |= (sign << 31);
        return ret;
    }

    // Clear up the sign
    arg &= ~(1ULL << 15);

    encodedExponent = arg >> 10;
    // Clear up the encoded exponent
    arg &= ~0x7C00ULL;

    // Exponent bias: 0xF
    realExponent = encodedExponent - 0xF;

    mantissaIsZero = (arg == 0);

    if (encodedExponent == 0) {
        // subnormals

        ret |= ((uint32_t)sign) << 31;
        // no need to set the exponent part since it was already zero'd

        // Set the mantissa
        ret |= arg >> (23 - 10);

        return ret;
    }

    if (encodedExponent == 0x1F) {
        // Infinity and NaN

        ret |= ((uint32_t)sign) << 31;
        ret |= 0x7F800000ULL;

        if (!mantissaIsZero) {
            // NaN

            // Set the mantissa to any non-zero value
            ret |= arg << (23 - 10);
        }

        return ret;
    }

    ret |= ((uint32_t)sign) << 31;

    // re-encode the exponent
    ret |= ((uint32_t)(realExponent + 0x7F)) << 23;

    // Set the mantissa
    ret |= arg << (23 - 10);

    return ret;
}