commit f1afc70c36f562fdb3cb9ae39a80e01c3dac1566
parent 4d0e68ae8339813f94cb46ed56140ae72031ae51
Author: Nihal Jere <nihal@nihaljere.xyz>
Date: Thu, 27 Jan 2022 23:36:21 -0600
use const
Obviously not exhaustive, but it's a good start.
Diffstat:
18 files changed, 172 insertions(+), 172 deletions(-)
diff --git a/array.c b/array.c
@@ -9,7 +9,7 @@
#include "array.h"
int
-_array_add(void **data, size_t *len, size_t *cap, void *new, size_t size, size_t count)
+_array_add(void **data, size_t *len, size_t *cap, const void *const new, const size_t size, const size_t count)
{
bool need_realloc;
while (*cap < *len + count) {
@@ -28,7 +28,7 @@ _array_add(void **data, size_t *len, size_t *cap, void *new, size_t size, size_t
// should only be called when size is 1
int
-_array_zero(void **data, size_t *len, size_t *cap, size_t count)
+_array_zero(void **data, size_t *len, size_t *cap, const size_t count)
{
bool need_realloc;
while (*cap < *len + count) {
diff --git a/array.h b/array.h
@@ -10,5 +10,5 @@
#define array_zero(arr, count) \
_array_zero((void **) &(arr->data), &(arr->len), &(arr->cap), count);
-int _array_add(void **data, size_t *len, size_t *cap, void *new, size_t size, size_t count);
-int _array_zero(void **data, size_t *len, size_t *cap, size_t count);
+int _array_add(void **data, size_t *len, size_t *cap, const void *const new, const size_t size, const size_t count);
+int _array_zero(void **data, size_t *len, size_t *cap, const size_t count);
diff --git a/blockstack.c b/blockstack.c
@@ -6,11 +6,11 @@
#include "ir.h"
#include "util.h"
-struct block *blockstack[BLOCKSTACKSIZE];
+const struct block *blockstack[BLOCKSTACKSIZE];
size_t blocki;
void
-blockpush(struct block *block)
+blockpush(const struct block *const block)
{
if (blocki >= BLOCKSTACKSIZE - 1)
die("blockpush: too many blocks!");
@@ -19,7 +19,7 @@ blockpush(struct block *block)
blocki++;
}
-struct block *
+const struct block *const
blockpop()
{
if (blocki == 0)
@@ -29,7 +29,7 @@ blockpop()
return blockstack[blocki];
}
-struct block *
+const struct block *const
blockpeek()
{
if (blocki == 0)
diff --git a/blockstack.h b/blockstack.h
@@ -1,3 +1,3 @@
-void blockpush(struct block *block);
+void blockpush(const struct block *const block);
struct block *blockpop();
struct block *blockpeek();
diff --git a/elf.c b/elf.c
@@ -6,7 +6,7 @@
#include "elf.h"
void
-elf(size_t entry, struct data *text, struct data *data, FILE *f)
+elf(const size_t entry, const struct data *const text, const struct data *const data, FILE *const f)
{
Elf64_Ehdr ehdr = { 0 };
Elf64_Phdr phdr_text = { 0 };
diff --git a/elf.h b/elf.h
@@ -1 +1 @@
-void elf(size_t entry, struct data *text, struct data *data, FILE *f);
+void elf(size_t entry, const struct data *const text, const struct data *const data, FILE *const f);
diff --git a/ir.c b/ir.c
@@ -48,17 +48,17 @@ regalloc()
}
static void
-regfree(uint8_t reg)
+regfree(const uint8_t reg)
{
assert(regs & (1 << reg));
regs &= ~(1 << reg);
}
static void
-genblock(struct iproc *out, struct block *block);
+genblock(struct iproc *const out, const struct block *const block);
static uint64_t
-procindex(struct slice *s)
+procindex(const struct slice *const s)
{
for (size_t i = 0; i < toplevel.code.len; i++) {
struct iproc *iproc = &toplevel.code.data[i];
@@ -71,7 +71,7 @@ procindex(struct slice *s)
}
static void
-putins(struct iproc *out, int op, uint64_t val, int valtype)
+putins(struct iproc *const out, const int op, const uint64_t val, const int valtype)
{
assert(op);
assert(valtype);
@@ -145,7 +145,7 @@ putins(struct iproc *out, int op, uint64_t val, int valtype)
}
static uint64_t
-bumplabel(struct iproc *out)
+bumplabel(struct iproc *const out)
{
uint64_t temp;
array_addlit((&out->labels), 0);
@@ -153,7 +153,7 @@ bumplabel(struct iproc *out)
}
static size_t
-assign(struct iproc *out, uint8_t size)
+assign(struct iproc *const out, const uint8_t size)
{
size_t t = NEWTMP;
STARTINS(IR_ASSIGN, t, VT_TEMP);
@@ -162,7 +162,7 @@ assign(struct iproc *out, uint8_t size)
}
static size_t
-immediate(struct iproc *out, uint8_t size, uint64_t val)
+immediate(struct iproc *const out, const uint8_t size, const uint64_t val)
{
size_t t = assign(out, size);
putins(out, IR_IMM, val, VT_IMM);
@@ -170,7 +170,7 @@ immediate(struct iproc *out, uint8_t size, uint64_t val)
}
static size_t
-load(struct iproc *out, uint8_t size, uint64_t index)
+load(struct iproc *const out, const uint8_t size, const uint64_t index)
{
size_t t = assign(out, size);;
putins(out, IR_LOAD, index, VT_TEMP);
@@ -178,7 +178,7 @@ load(struct iproc *out, uint8_t size, uint64_t index)
}
static size_t
-alloc(struct iproc *out, uint8_t size, uint64_t count)
+alloc(struct iproc *const out, const uint8_t size, const uint64_t count)
{
size_t t = assign(out, size);
out->temps.data[t].flags = TF_PTR;
@@ -187,14 +187,14 @@ alloc(struct iproc *out, uint8_t size, uint64_t count)
}
static void
-store(struct iproc *out, uint8_t size, uint64_t src, uint64_t dest)
+store(struct iproc *const out, const uint8_t size, const uint64_t src, const uint64_t dest)
{
STARTINS(IR_STORE, src, VT_TEMP);
putins(out, IR_EXTRA, dest, VT_TEMP);
}
static int
-genexpr(struct iproc *out, size_t expri, uint64_t *val)
+genexpr(struct iproc *const out, const size_t expri, uint64_t *const val)
{
struct expr *expr = &exprs.data[expri];
uint64_t temp2 = 0;
@@ -364,7 +364,7 @@ genexpr(struct iproc *out, size_t expri, uint64_t *val)
}
static void
-genassign(struct iproc *out, struct decl *decl, size_t val)
+genassign(struct iproc *const out, const struct decl *const decl, const size_t val)
{
struct type *type = &types.data[decl->type];
uint64_t what;
@@ -388,7 +388,7 @@ genassign(struct iproc *out, struct decl *decl, size_t val)
}
static void
-genblock(struct iproc *out, struct block *block)
+genblock(struct iproc *const out, const struct block *const block)
{
struct decl *decl;
struct type *type;
@@ -431,7 +431,7 @@ genblock(struct iproc *out, struct block *block)
}
static void
-chooseregs(struct iproc *proc)
+chooseregs(struct iproc *const proc)
{
bool active[proc->temps.len];
memset(active, 0, proc->temps.len * sizeof(*active));
@@ -466,7 +466,7 @@ chooseregs(struct iproc *proc)
}
size_t
-genproc(struct decl *decl, struct proc *proc)
+genproc(struct decl *const decl, const struct proc *const proc)
{
tmpi = labeli = curi = 1;
rblocki = reali = 0;
diff --git a/ir.h b/ir.h
@@ -96,10 +96,10 @@ struct toplevel {
uint64_t entry;
};
-size_t genproc(struct decl *decl, struct proc *proc);
+size_t genproc(struct decl *const decl, const struct proc *const proc);
struct target {
uint32_t reserved;
- size_t (*emitsyscall)(struct data *text, uint8_t paramcount);
- size_t (*emitproc)(struct data *text, struct iproc *proc);
+ size_t (*emitsyscall)(struct data *const text, const uint8_t paramcount);
+ size_t (*emitproc)(struct data *const text, const struct iproc *const proc);
};
diff --git a/lex.c b/lex.c
@@ -18,7 +18,7 @@ lex(struct slice start)
{
size_t line = 1;
size_t col = 1;
- struct token *head = calloc(1, sizeof(struct token));
+ struct token *const head = calloc(1, sizeof(struct token));
if (!head)
return NULL;
diff --git a/main.c b/main.c
@@ -38,21 +38,21 @@ struct toplevel toplevel;
char *infile;
uint64_t
-data_push(char *ptr, size_t len)
+data_push(const char *const ptr, const size_t len)
{
array_push((&toplevel.data), ptr, len);
return DATA_OFFSET + toplevel.data.len - len;
}
uint64_t
-data_pushzero(size_t len)
+data_pushzero(const size_t len)
{
array_zero((&toplevel.data), len);
return DATA_OFFSET + toplevel.data.len - len;
}
void
-data_set(uint64_t addr, void *ptr, size_t len)
+data_set(const uint64_t addr, const void *const ptr, const size_t len)
{
memcpy(&toplevel.data.data[addr - DATA_OFFSET], ptr, len);
}
@@ -60,9 +60,9 @@ data_set(uint64_t addr, void *ptr, size_t len)
void
decl_alloc(struct block *block, struct decl *decl)
{
- struct type *type = &types.data[decl->type];
+ const struct type *const type = &types.data[decl->type];
if (type->class == TYPE_ARRAY) {
- struct type *subtype = &types.data[type->d.arr.subtype];
+ const struct type *const subtype = &types.data[type->d.arr.subtype];
decl->w.addr = data_pushzero(subtype->size * type->d.arr.len);
} else {
decl->w.addr = data_pushzero(type->size);
@@ -70,18 +70,18 @@ decl_alloc(struct block *block, struct decl *decl)
}
void
-evalexpr(struct decl *decl)
+evalexpr(struct decl *const decl)
{
struct expr *expr = &exprs.data[decl->val];
if (expr->kind == EXPR_LIT) {
switch (expr->class) {
case C_INT: {
- struct type *type = &types.data[decl->type];
+ const struct type *const type = &types.data[decl->type];
data_set(decl->w.addr, &expr->d.v.v, type->size);
break;
}
case C_STR: {
- uint64_t addr = data_push(expr->d.v.v.s.data, expr->d.v.v.s.len);
+ const uint64_t addr = data_push(expr->d.v.v.s.data, expr->d.v.v.s.len);
decl->w.addr = addr;
break;
}
@@ -111,7 +111,7 @@ gentoplevel(struct toplevel *toplevel, struct block *block)
curaddr += targ.emitsyscall(&toplevel->text, i);
}
for (int i = 0; i < block->len; i++) {
- struct statement *statement = &block->data[i];
+ const struct statement *const statement = &block->data[i];
switch (statement->kind) {
case STMT_EXPR:
@@ -119,8 +119,8 @@ gentoplevel(struct toplevel *toplevel, struct block *block)
case STMT_ASSGN:
die("toplevel assignments are unimplemented");
case STMT_DECL: {
- struct decl *decl = &block->decls.data[statement->idx];
- struct expr *expr = &exprs.data[decl->val];
+ struct decl *const decl = &block->decls.data[statement->idx];
+ struct expr *const expr = &exprs.data[decl->val];
decl_alloc(block, decl);
@@ -159,7 +159,7 @@ main(int argc, char *argv[])
}
infile = argv[1];
- int in = open(infile, 0, O_RDONLY);
+ const int in = open(infile, 0, O_RDONLY);
if (in < 0) {
fprintf(stderr, "couldn't open input\n");
return 1;
@@ -171,14 +171,14 @@ main(int argc, char *argv[])
return 1;
}
- char *addr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, in, 0);
+ char *const addr = mmap(NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, in, 0);
close(in);
if (addr == NULL) {
fprintf(stderr, "failed to map input file into memory\n");
return 1;
}
- struct token *head = lex((struct slice){statbuf.st_size, statbuf.st_size, addr});
+ const struct token *const head = lex((struct slice){statbuf.st_size, statbuf.st_size, addr});
typesmap = mkmap(16);
inittypes();
@@ -186,7 +186,7 @@ main(int argc, char *argv[])
gentoplevel(&toplevel, &statements);
- FILE *out = fopen(argv[2], "w");
+ FILE *const out = fopen(argv[2], "w");
if (!out) {
close(in);
fprintf(stderr, "couldn't open output\n");
diff --git a/nooc.h b/nooc.h
@@ -108,7 +108,7 @@ struct nametypes {
struct assgn {
struct slice s;
size_t val; // struct exprs
- struct token *start;
+ const struct token *start;
};
struct assgns {
@@ -130,7 +130,7 @@ struct decl {
int64_t offset;
uint64_t addr;
} w;
- struct token *start;
+ const struct token *start;
};
struct decls {
@@ -153,7 +153,7 @@ struct statement {
STMT_RETURN,
} kind;
size_t idx;
- struct token *start;
+ const struct token *start;
};
struct block {
@@ -243,7 +243,7 @@ struct expr {
struct loop loop;
struct proc proc;
} d;
- struct token *start;
+ const struct token *start;
};
struct exprs {
diff --git a/parse.c b/parse.c
@@ -22,13 +22,13 @@ extern struct exprs exprs;
extern struct types types;
extern struct map *typesmap;
-struct token *tok;
+const struct token *tok;
-static void parsenametypes(struct nametypes *nametypes);
+static void parsenametypes(struct nametypes *const nametypes);
static size_t parsetype();
struct decl *
-finddecl(struct slice s)
+finddecl(const struct slice s)
{
for (int j = blocki - 1; j >= 0; j--) {
for (int i = 0; i < blockstack[j]->decls.len; i++) {
@@ -43,7 +43,7 @@ finddecl(struct slice s)
}
static void
-expect(enum tokentype type)
+expect(const enum tokentype type)
{
if (!tok)
error(tok->line, tok->col, "unexpected null token!");
@@ -53,7 +53,7 @@ expect(enum tokentype type)
}
static void
-parsestring(struct expr *expr)
+parsestring(struct expr *const expr)
{
expr->start = tok;
expr->kind = EXPR_LIT;
@@ -89,7 +89,7 @@ parsestring(struct expr *expr)
}
static void
-parsenum(struct expr *expr)
+parsenum(struct expr *const expr)
{
expr->start = tok;
expr->kind = EXPR_LIT;
@@ -110,7 +110,7 @@ parsenum(struct expr *expr)
}
enum class
-typetoclass(struct type *type)
+typetoclass(const struct type *const type)
{
switch (type->class) {
case TYPE_INT:
@@ -126,10 +126,10 @@ typetoclass(struct type *type)
return 0; // warning
}
-static void parseblock(struct block *block);
+static void parseblock(struct block *const block);
static size_t
-parseexpr(struct block *block)
+parseexpr(struct block *const block)
{
struct expr expr = { 0 };
switch (tok->type) {
@@ -300,7 +300,7 @@ binary_common:
}
void
-parsetypelist(struct typelist *list)
+parsetypelist(struct typelist *const list)
{
expect(TOK_LPAREN);
tok = tok->next;
@@ -371,7 +371,7 @@ parsetype()
}
static void
-parsenametypes(struct nametypes *nametypes)
+parsenametypes(struct nametypes *const nametypes)
{
expect(TOK_LPAREN);
tok = tok->next;
@@ -398,7 +398,7 @@ parsenametypes(struct nametypes *nametypes)
}
static void
-parseblock(struct block *block)
+parseblock(struct block *const block)
{
struct statement statement;
bool curlies = false;
@@ -469,7 +469,7 @@ parseblock(struct block *block)
}
struct block
-parse(struct token *start)
+parse(const struct token *const start)
{
tok = start;
struct block block = { 0 };
diff --git a/parse.h b/parse.h
@@ -1,3 +1,3 @@
-struct block parse(struct token *tok);
+struct block parse(const struct token *const tok);
struct nametype *findparam(struct nametypes *params, struct slice s);
struct decl *finddecl(struct slice s);
diff --git a/type.c b/type.c
@@ -70,7 +70,7 @@ inittypes()
}
static void
-hashtype(struct type *type, uint8_t *out)
+hashtype(const struct type *const type, uint8_t *const out)
{
static bool empty_found = false;
struct blake3 b3;
@@ -100,8 +100,8 @@ hashtype(struct type *type, uint8_t *out)
blake3_out(&b3, out, 16);
}
-static size_t
-getindex(uint8_t hash[16])
+static const size_t
+getindex(const uint8_t hash[16])
{
uint64_t i = hash[0] & (table.cap - 1);
while (table.keys[i].present && memcmp(table.keys[i].hash, hash, 16)) {
@@ -111,23 +111,23 @@ getindex(uint8_t hash[16])
return i;
}
-size_t
-type_query(struct type *type)
+const size_t
+type_query(const struct type *const type)
{
uint8_t hash[16];
hashtype(type, hash);
return type_get(hash);
}
-size_t
-type_get(uint8_t hash[16])
+const size_t
+type_get(const uint8_t hash[16])
{
size_t i = getindex(hash);
return table.keys[i].present ? table.vals[i] : 0;
}
-size_t
-type_put(struct type *type)
+const size_t
+type_put(const struct type *const type)
{
struct typekey *oldkeys;
size_t *oldvals, oldcap, i, j;
@@ -166,7 +166,7 @@ type_put(struct type *type)
}
void
-typecompat(size_t typei, size_t expri)
+typecompat(const size_t typei, const size_t expri)
{
struct type *type = &types.data[typei];
struct expr *expr = &exprs.data[expri];
@@ -201,8 +201,8 @@ typecompat(size_t typei, size_t expri)
}
}
-size_t
-typeref(size_t typei)
+const size_t
+typeref(const size_t typei)
{
struct type ref = {
.class = TYPE_REF,
@@ -214,7 +214,7 @@ typeref(size_t typei)
}
static void
-typecheckcall(struct expr *expr)
+typecheckcall(const struct expr *const expr)
{
assert(expr->kind == EXPR_FCALL);
struct decl *fdecl = finddecl(expr->d.call.name);
@@ -238,7 +238,7 @@ typecheckcall(struct expr *expr)
}
static void
-typecheckexpr(size_t expri)
+typecheckexpr(const size_t expri)
{
struct expr *expr = &exprs.data[expri];
switch (expr->kind) {
@@ -266,10 +266,10 @@ typecheckexpr(size_t expri)
}
void
-typecheck(struct block *block)
+typecheck(const struct block *const block)
{
for (size_t i = 0; i < block->len; i++) {
- struct statement *statement = &block->data[i];
+ const struct statement *const statement = &block->data[i];
struct decl *decl;
struct assgn *assgn;
switch (block->data[i].kind) {
diff --git a/type.h b/type.h
@@ -1,5 +1,5 @@
-size_t type_get(uint8_t hash[16]);
-size_t type_put(struct type *type);
+const size_t type_get(const uint8_t hash[16]);
+const size_t type_put(const struct type *const type);
void inittypes();
-size_t typeref(size_t typei);
-void typecheck(struct block *block);
+const size_t typeref(const size_t typei);
+void typecheck(const struct block *const block);
diff --git a/util.c b/util.c
@@ -34,8 +34,8 @@ const char *const tokenstr[] = {
[TOK_RETURN] = "TOK_RETURN",
};
-char *
-exprkind_str(enum exprkind kind)
+const char *const
+exprkind_str(const enum exprkind kind)
{
switch (kind) {
case EXPR_LIT:
@@ -56,7 +56,7 @@ exprkind_str(enum exprkind kind)
}
void
-dumpval(struct expr *e)
+dumpval(const struct expr *const e)
{
switch (e->class) {
case C_INT:
@@ -75,7 +75,7 @@ dumpval(struct expr *e)
}
void
-dumpbinop(struct binop *op)
+dumpbinop(const struct binop *const op)
{
switch (op->kind) {
case BOP_PLUS:
@@ -96,7 +96,7 @@ dumpbinop(struct binop *op)
}
void
-dumpexpr(int indent, struct expr *expr)
+dumpexpr(const int indent, const struct expr *const expr)
{
for (int i = 0; i < indent; i++)
fputc(' ', stderr);
@@ -127,7 +127,7 @@ dumpexpr(int indent, struct expr *expr)
}
static char
-sigil(int valtype)
+sigil(const int valtype)
{
switch (valtype) {
case VT_EMPTY:
@@ -147,7 +147,7 @@ sigil(int valtype)
}
void
-dumpir(struct iproc *instrs)
+dumpir(const struct iproc *const instrs)
{
bool callarg = false;
char sig;
@@ -232,7 +232,7 @@ dumpir(struct iproc *instrs)
}
int
-slice_cmp(struct slice *s1, struct slice *s2)
+slice_cmp(const struct slice *const s1, const struct slice *const s2)
{
if (s1->len != s2->len)
return 1;
@@ -241,7 +241,7 @@ slice_cmp(struct slice *s1, struct slice *s2)
}
int
-slice_cmplit(struct slice *s1, char *s2)
+slice_cmplit(const struct slice *const s1, const char *const s2)
{
size_t len = strlen(s2);
if (s1->len < len)
@@ -251,7 +251,7 @@ slice_cmplit(struct slice *s1, char *s2)
}
void
-error(size_t line, size_t col, const char *error, ...)
+error(const size_t line, const size_t col, const char *error, ...)
{
va_list args;
@@ -264,14 +264,14 @@ error(size_t line, size_t col, const char *error, ...)
}
void
-die(char *error)
+die(const char *const error)
{
fprintf(stderr, "%s\n", error);
exit(1);
}
void *
-xmalloc(size_t size)
+xmalloc(const size_t size)
{
char *p = malloc(size);
if (!p)
diff --git a/util.h b/util.h
@@ -1,12 +1,12 @@
-char *exprkind_str(enum exprkind kind);
-void dumpval(struct expr *e);
-void dumpbinop(struct binop *op);
-void dumpexpr(int indent, struct expr *expr);
-void dumpir(struct iproc *instrs);
-int slice_cmp(struct slice *s1, struct slice *s2);
-int slice_cmplit(struct slice *s1, char *s2);
-void error(size_t line, size_t col, const char *error, ...);
-void die(char *error);
+const char *const exprkind_str(const enum exprkind kind);
+void dumpval(const struct expr *const e);
+void dumpbinop(const struct binop *const op);
+void dumpexpr(const int indent, const struct expr *const expr);
+void dumpir(const struct iproc *const instrs);
+int slice_cmp(const struct slice *const s1, const struct slice *const s2);
+int slice_cmplit(const struct slice *const s1, const char *const s2);
+void error(const size_t line, const size_t col, const char *error, ...);
+void die(const char *const error);
void *xmalloc(size_t size);
void *xrealloc(void *, size_t);
void *xcalloc(size_t, size_t);
diff --git a/x64.c b/x64.c
@@ -50,7 +50,7 @@ unsigned short used_reg;
extern struct toplevel toplevel;
static size_t
-add_r64_imm(struct data *text, enum reg dest, uint64_t imm)
+add_r64_imm(struct data *const text, const enum reg dest, const uint64_t imm)
{
uint8_t temp;
if (text) {
@@ -67,7 +67,7 @@ add_r64_imm(struct data *text, enum reg dest, uint64_t imm)
}
static size_t
-mov_r64_imm(struct data *text, enum reg dest, uint64_t imm)
+mov_r64_imm(struct data *const text, const enum reg dest, const uint64_t imm)
{
uint8_t temp;
if (text) {
@@ -87,7 +87,7 @@ mov_r64_imm(struct data *text, enum reg dest, uint64_t imm)
}
static size_t
-mov_r32_imm(struct data *text, enum reg dest, uint32_t imm)
+mov_r32_imm(struct data *const text, const enum reg dest, const uint32_t imm)
{
uint8_t temp;
if (text) {
@@ -102,7 +102,7 @@ mov_r32_imm(struct data *text, enum reg dest, uint32_t imm)
}
static size_t
-mov_r16_imm(struct data *text, enum reg dest, uint16_t imm)
+mov_r16_imm(struct data *const text, const enum reg dest, const uint16_t imm)
{
uint8_t temp;
if (text) {
@@ -116,7 +116,7 @@ mov_r16_imm(struct data *text, enum reg dest, uint16_t imm)
}
static size_t
-mov_r8_imm(struct data *text, enum reg dest, uint8_t imm)
+mov_r8_imm(struct data *const text, const enum reg dest, const uint8_t imm)
{
uint8_t temp;
if (text) {
@@ -128,7 +128,7 @@ mov_r8_imm(struct data *text, enum reg dest, uint8_t imm)
}
static size_t
-mov_r64_m64(struct data *text, enum reg dest, uint64_t addr)
+mov_r64_m64(struct data *const text, const enum reg dest, const uint64_t addr)
{
uint8_t temp;
if (text) {
@@ -146,7 +146,7 @@ mov_r64_m64(struct data *text, enum reg dest, uint64_t addr)
}
static size_t
-mov_r32_m32(struct data *text, enum reg dest, uint32_t addr)
+mov_r32_m32(struct data *const text, const enum reg dest, const uint32_t addr)
{
uint8_t temp;
if (text) {
@@ -164,7 +164,7 @@ mov_r32_m32(struct data *text, enum reg dest, uint32_t addr)
}
static size_t
-mov_r16_m16(struct data *text, enum reg dest, uint32_t addr)
+mov_r16_m16(struct data *const text, const enum reg dest, const uint32_t addr)
{
uint8_t temp;
if (text) {
@@ -183,7 +183,7 @@ mov_r16_m16(struct data *text, enum reg dest, uint32_t addr)
}
static size_t
-mov_r8_m8(struct data *text, enum reg dest, uint32_t addr)
+mov_r8_m8(struct data *const text, const enum reg dest, const uint32_t addr)
{
uint8_t temp;
if (text) {
@@ -201,7 +201,7 @@ mov_r8_m8(struct data *text, enum reg dest, uint32_t addr)
}
static size_t
-mov_m64_r64(struct data *text, uint64_t addr, enum reg src)
+mov_m64_r64(struct data *const text, const uint64_t addr, const enum reg src)
{
uint8_t temp;
if (text) {
@@ -221,7 +221,7 @@ mov_m64_r64(struct data *text, uint64_t addr, enum reg src)
}
static size_t
-mov_m32_r32(struct data *text, uint64_t addr, enum reg src)
+mov_m32_r32(struct data *const text, const uint64_t addr, const enum reg src)
{
uint8_t temp;
if (text) {
@@ -243,7 +243,7 @@ mov_m32_r32(struct data *text, uint64_t addr, enum reg src)
#define MOVE_TOREG 1
static size_t
-_move_between_reg_and_memaddr_in_reg(struct data *text, enum reg reg, enum reg mem, uint8_t opsize, bool dir)
+_move_between_reg_and_memaddr_in_reg(struct data *const text, const enum reg reg, const enum reg mem, const uint8_t opsize, const bool dir)
{
uint8_t temp, rex = opsize == 8 ? REX_W : 0;
rex |= (reg >= 8 ? REX_R : 0) | (mem >= 8 ? REX_B : 0);
@@ -265,55 +265,55 @@ _move_between_reg_and_memaddr_in_reg(struct data *text, enum reg reg, enum reg m
}
static size_t
-mov_mr64_r64(struct data *text, enum reg dest, enum reg src)
+mov_mr64_r64(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, src, dest, 8, MOVE_FROMREG);
}
static size_t
-mov_mr32_r32(struct data *text, enum reg dest, enum reg src)
+mov_mr32_r32(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, src, dest, 4, MOVE_FROMREG);
}
static size_t
-mov_mr16_r16(struct data *text, enum reg dest, enum reg src)
+mov_mr16_r16(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, src, dest, 2, MOVE_FROMREG);
}
static size_t
-mov_mr8_r8(struct data *text, enum reg dest, enum reg src)
+mov_mr8_r8(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, src, dest, 1, MOVE_FROMREG);
}
static size_t
-mov_r64_mr64(struct data *text, enum reg dest, enum reg src)
+mov_r64_mr64(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, dest, src, 8, MOVE_TOREG);
}
static size_t
-mov_r32_mr32(struct data *text, enum reg dest, enum reg src)
+mov_r32_mr32(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, dest, src, 4, MOVE_TOREG);
}
static size_t
-mov_r16_mr16(struct data *text, enum reg dest, enum reg src)
+mov_r16_mr16(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, dest, src, 2, MOVE_TOREG);
}
static size_t
-mov_r8_mr8(struct data *text, enum reg dest, enum reg src)
+mov_r8_mr8(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg(text, dest, src, 1, MOVE_TOREG);
}
static size_t
-_move_between_reg_and_reg(struct data *text, enum reg dest, enum reg src, uint8_t opsize)
+_move_between_reg_and_reg(struct data *const text, const enum reg dest, const enum reg src, const uint8_t opsize)
{
uint8_t temp, rex = (src >= 8 ? REX_R : 0) | (dest >= 8 ? REX_B : 0) | (opsize == 8 ? REX_W : 0);
if (text) {
@@ -331,31 +331,31 @@ _move_between_reg_and_reg(struct data *text, enum reg dest, enum reg src, uint8_
}
static size_t
-mov_r64_r64(struct data *text, enum reg dest, enum reg src)
+mov_r64_r64(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_reg(text, dest, src, 8);
}
static size_t
-mov_r32_r32(struct data *text, enum reg dest, enum reg src)
+mov_r32_r32(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_reg(text, dest, src, 4);
}
static size_t
-mov_r16_r16(struct data *text, enum reg dest, enum reg src)
+mov_r16_r16(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_reg(text, dest, src, 2);
}
static size_t
-mov_r8_r8(struct data *text, enum reg dest, enum reg src)
+mov_r8_r8(struct data *const text, const enum reg dest, const enum reg src)
{
return _move_between_reg_and_reg(text, dest, src, 1);
}
static size_t
-_move_between_reg_and_memaddr_in_reg_with_disp(struct data *text, enum reg reg, enum reg mem, int8_t disp, uint8_t opsize, bool dir)
+_move_between_reg_and_memaddr_in_reg_with_disp(struct data *const text, const enum reg reg, const enum reg mem, const int8_t disp, const uint8_t opsize, const bool dir)
{
assert((reg & 7) != 4 && (mem & 7) != 4);
uint8_t temp, rex = opsize == 8 ? REX_W : 0;
@@ -379,55 +379,55 @@ _move_between_reg_and_memaddr_in_reg_with_disp(struct data *text, enum reg reg,
}
static size_t
-mov_disp8_m64_r64(struct data *text, enum reg dest, int8_t disp, enum reg src)
+mov_disp8_m64_r64(struct data *const text, const enum reg dest, const int8_t disp, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, src, dest, disp, 8, MOVE_FROMREG);
}
static size_t
-mov_disp8_m32_r32(struct data *text, enum reg dest, int8_t disp, enum reg src)
+mov_disp8_m32_r32(struct data *const text, const enum reg dest, const int8_t disp, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, src, dest, disp, 4, MOVE_FROMREG);
}
static size_t
-mov_disp8_m16_r16(struct data *text, enum reg dest, int8_t disp, enum reg src)
+mov_disp8_m16_r16(struct data *const text, const enum reg dest, const int8_t disp, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, src, dest, disp, 2, MOVE_FROMREG);
}
static size_t
-mov_disp8_m8_r8(struct data *text, enum reg dest, int8_t disp, enum reg src)
+mov_disp8_m8_r8(struct data *const text, const enum reg dest, const int8_t disp, const enum reg src)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, src, dest, disp, 1, MOVE_FROMREG);
}
static size_t
-mov_disp8_r64_m64(struct data *text, enum reg dest, enum reg src, int8_t disp)
+mov_disp8_r64_m64(struct data *const text, const enum reg dest, const enum reg src, const int8_t disp)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, dest, src, disp, 8, MOVE_TOREG);
}
static size_t
-mov_disp8_r32_m32(struct data *text, enum reg dest, enum reg src, int8_t disp)
+mov_disp8_r32_m32(struct data *const text, const enum reg dest, const enum reg src, const int8_t disp)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, dest, src, disp, 4, MOVE_TOREG);
}
static size_t
-mov_disp8_r16_m16(struct data *text, enum reg dest, enum reg src, int8_t disp)
+mov_disp8_r16_m16(struct data *const text, const enum reg dest, const enum reg src, const int8_t disp)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, dest, src, disp, 2, MOVE_TOREG);
}
static size_t
-mov_disp8_r8_m8(struct data *text, enum reg dest, enum reg src, int8_t disp)
+mov_disp8_r8_m8(struct data *const text, const enum reg dest, const enum reg src, const int8_t disp)
{
return _move_between_reg_and_memaddr_in_reg_with_disp(text, dest, src, disp, 1, MOVE_TOREG);
}
static size_t
-_movezx_reg_to_reg(struct data *text, uint8_t destsize, uint8_t srcsize, enum reg dest, enum reg src)
+_movezx_reg_to_reg(struct data *const text, const uint8_t destsize, const uint8_t srcsize, const enum reg dest, const enum reg src)
{
assert(srcsize == 1 || srcsize == 2);
assert(destsize == 1 || destsize == 2 || destsize == 4 || destsize == 8);
@@ -449,37 +449,37 @@ _movezx_reg_to_reg(struct data *text, uint8_t destsize, uint8_t srcsize, enum re
}
static size_t
-movzx_r64_r8(struct data *text, enum reg dest, enum reg src)
+movzx_r64_r8(struct data *const text, const enum reg dest, const enum reg src)
{
return _movezx_reg_to_reg(text, 8, 1, dest, src);
}
static size_t
-movzx_r32_r8(struct data *text, enum reg dest, enum reg src)
+movzx_r32_r8(struct data *const text, const enum reg dest, const enum reg src)
{
return _movezx_reg_to_reg(text, 4, 1, dest, src);
}
static size_t
-movzx_r16_r8(struct data *text, enum reg dest, enum reg src)
+movzx_r16_r8(struct data *const text, const enum reg dest, const enum reg src)
{
return _movezx_reg_to_reg(text, 2, 1, dest, src);
}
static size_t
-movzx_r64_r16(struct data *text, enum reg dest, enum reg src)
+movzx_r64_r16(struct data *const text, const enum reg dest, const enum reg src)
{
return _movezx_reg_to_reg(text, 8, 2, dest, src);
}
static size_t
-movzx_r32_r16(struct data *text, enum reg dest, enum reg src)
+movzx_r32_r16(struct data *const text, const enum reg dest, const enum reg src)
{
return _movezx_reg_to_reg(text, 4, 2, dest, src);
}
static size_t
-lea_disp8(struct data *text, enum reg dest, enum reg src, int8_t disp)
+lea_disp8(struct data *const text, const enum reg dest, const enum reg src, const int8_t disp)
{
uint8_t temp;
assert(src != 4);
@@ -494,7 +494,7 @@ lea_disp8(struct data *text, enum reg dest, enum reg src, int8_t disp)
}
static size_t
-add_r64_r64(struct data *text, enum reg dest, enum reg src)
+add_r64_r64(struct data *const text, const enum reg dest, const enum reg src)
{
uint8_t temp;
if (text) {
@@ -507,7 +507,7 @@ add_r64_r64(struct data *text, enum reg dest, enum reg src)
}
static size_t
-sub_r64_r64(struct data *text, enum reg dest, enum reg src)
+sub_r64_r64(struct data *const text, const enum reg dest, const enum reg src)
{
uint8_t temp;
if (text) {
@@ -520,7 +520,7 @@ sub_r64_r64(struct data *text, enum reg dest, enum reg src)
}
static size_t
-sub_r64_imm(struct data *text, enum reg dest, int32_t imm)
+sub_r64_imm(struct data *const text, const enum reg dest, int32_t imm)
{
uint8_t temp;
if (text) {
@@ -537,7 +537,7 @@ sub_r64_imm(struct data *text, enum reg dest, int32_t imm)
}
static size_t
-_cmp_reg_to_reg(struct data *text, uint8_t size, enum reg reg1, enum reg reg2)
+_cmp_reg_to_reg(struct data *const text, const uint8_t size, const enum reg reg1, const enum reg reg2)
{
uint8_t temp;
uint8_t rex = (size == 8 ? REX_W : 0) | (reg1 >= 8 ? REX_R : 0) | (reg2 >= 8 ? REX_B : 0);
@@ -556,31 +556,31 @@ _cmp_reg_to_reg(struct data *text, uint8_t size, enum reg reg1, enum reg reg2)
}
static size_t
-cmp_r64_r64(struct data *text, enum reg reg1, enum reg reg2)
+cmp_r64_r64(struct data *const text, const enum reg reg1, const enum reg reg2)
{
return _cmp_reg_to_reg(text, 8, reg1, reg2);
}
static size_t
-cmp_r32_r32(struct data *text, enum reg reg1, enum reg reg2)
+cmp_r32_r32(struct data *const text, const enum reg reg1, const enum reg reg2)
{
return _cmp_reg_to_reg(text, 4, reg1, reg2);
}
static size_t
-cmp_r16_r16(struct data *text, enum reg reg1, enum reg reg2)
+cmp_r16_r16(struct data *const text, const enum reg reg1, const enum reg reg2)
{
return _cmp_reg_to_reg(text, 2, reg1, reg2);
}
static size_t
-cmp_r8_r8(struct data *text, enum reg reg1, enum reg reg2)
+cmp_r8_r8(struct data *const text, const enum reg reg1, const enum reg reg2)
{
return _cmp_reg_to_reg(text, 1, reg1, reg2);
}
static size_t
-cmp_r8_imm(struct data *text, enum reg reg, uint8_t imm)
+cmp_r8_imm(struct data *const text, const enum reg reg, const uint8_t imm)
{
uint8_t temp;
if (text) {
@@ -595,7 +595,7 @@ cmp_r8_imm(struct data *text, enum reg reg, uint8_t imm)
}
static size_t
-jng(struct data *text, int64_t offset)
+jng(struct data *const text, const int64_t offset)
{
uint8_t temp;
if (-256 <= offset && offset <= 255) {
@@ -613,7 +613,7 @@ jng(struct data *text, int64_t offset)
}
static size_t
-jg(struct data *text, int64_t offset)
+jg(struct data *const text, const int64_t offset)
{
uint8_t temp;
if (-256 <= offset && offset <= 255) {
@@ -631,7 +631,7 @@ jg(struct data *text, int64_t offset)
}
static size_t
-jne(struct data *text, int64_t offset)
+jne(struct data *const text, const int64_t offset)
{
uint8_t temp;
if (-256 <= offset && offset <= 255) {
@@ -649,7 +649,7 @@ jne(struct data *text, int64_t offset)
}
static size_t
-je(struct data *text, int64_t offset)
+je(struct data *const text, const int64_t offset)
{
uint8_t temp;
if (-128 <= offset && offset <= 127) {
@@ -678,7 +678,7 @@ je(struct data *text, int64_t offset)
}
static size_t
-sete_reg(struct data *text, enum reg reg)
+sete_reg(struct data *const text, const enum reg reg)
{
uint8_t temp;
if (text) {
@@ -692,7 +692,7 @@ sete_reg(struct data *text, enum reg reg)
}
static size_t
-setne_reg(struct data *text, enum reg reg)
+setne_reg(struct data *const text, const enum reg reg)
{
uint8_t temp;
if (text) {
@@ -706,7 +706,7 @@ setne_reg(struct data *text, enum reg reg)
}
static size_t
-jmp(struct data *text, int64_t offset)
+jmp(struct data *const text, const int64_t offset)
{
uint8_t temp;
if (-256 <= offset && offset <= 255) {
@@ -724,7 +724,7 @@ jmp(struct data *text, int64_t offset)
}
static size_t
-call(struct data *text, int32_t offset)
+call(struct data *const text, const int32_t offset)
{
uint8_t temp;
if (text) {
@@ -739,7 +739,7 @@ call(struct data *text, int32_t offset)
}
static size_t
-ret(struct data *text)
+ret(struct data *const text)
{
uint8_t temp;
if (text)
@@ -749,7 +749,7 @@ ret(struct data *text)
}
static size_t
-_pushpop_r64(struct data *text, uint8_t ioff, enum reg reg)
+_pushpop_r64(struct data *const text, const uint8_t ioff, const enum reg reg)
{
uint8_t temp;
if (text) {
@@ -763,19 +763,19 @@ _pushpop_r64(struct data *text, uint8_t ioff, enum reg reg)
}
static size_t
-push_r64(struct data *text, enum reg reg)
+push_r64(struct data *const text, const enum reg reg)
{
return _pushpop_r64(text, 0, reg);
}
static size_t
-pop_r64(struct data *text, enum reg reg)
+pop_r64(struct data *const text, const enum reg reg)
{
return _pushpop_r64(text, 8, reg);
}
-static size_t emitsyscall(struct data *text, uint8_t paramcount);
-static size_t emitproc(struct data *text, struct iproc *proc);
+static size_t emitsyscall(struct data *const text, const uint8_t paramcount);
+static size_t emitproc(struct data *const text, const struct iproc *const proc);
const struct target x64_target = {
.reserved = (1 << RSP) | (1 << RBP) | (1 << R12) | (1 << R13),
@@ -786,7 +786,7 @@ const struct target x64_target = {
#define NEXT ins++; assert(ins <= end);
static size_t
-emitsyscall(struct data *text, uint8_t paramcount)
+emitsyscall(struct data *const text, const uint8_t paramcount)
{
assert(paramcount < 8);
size_t total = 0;
@@ -820,9 +820,9 @@ emitsyscall(struct data *text, uint8_t paramcount)
}
size_t
-emitblock(struct data *text, struct iproc *proc, struct instr *start, struct instr *end, uint16_t active, uint16_t curi)
+emitblock(struct data *const text, const struct iproc *const proc, const struct instr *const start, const struct instr *end, uint16_t active, uint16_t curi)
{
- struct instr *ins = start ? start : proc->data;
+ const struct instr *ins = start ? start : proc->data;
end = end ? end : &proc->data[proc->len];
uint64_t dest, src, size, count, label;
@@ -1061,7 +1061,7 @@ emitblock(struct data *text, struct iproc *proc, struct instr *start, struct ins
}
size_t
-emitproc(struct data *text, struct iproc *proc)
+emitproc(struct data *const text, const struct iproc *const proc)
{
return emitblock(text, proc, NULL, NULL, 0, 0);
}
