Rizin
unix-like reverse engineering framework and cli tools
rcond.c
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: 2014-2019 pancake <pancake@nopcode.org>
2 // SPDX-License-Identifier: LGPL-3.0-only
3 
4 #include <rz_reg.h>
5 
6 #undef Z
7 #undef S
8 #undef C
9 #undef O
10 #undef P
11 #define Z f->z
12 #define S f->s
13 #define C f->c
14 #define O f->o
15 #define P f->p
16 
18  int i = RZ_REG_TYPE_GPR;
20  RzRegItem *r;
22 
23  rz_list_foreach (reg->regset[i].regs, iter, r) {
24  if (r->flags && !strcmp(name, r->flags)) {
25  return r;
26  }
27  }
28  return NULL;
29 }
30 
31 RZ_API int rz_reg_cond_get_value(RzReg *r, const char *name) {
33  if (!ri) {
34  return 0;
35  }
36  return (int)rz_reg_get_value(r, ri) ? 1 : 0;
37 }
38 
39 RZ_API bool rz_reg_cond_set(RzReg *r, const char *name, bool val) {
40  RzRegItem *item = rz_reg_cond_get(r, name);
41  if (item) {
42  rz_reg_set_value(r, item, val);
43  return true;
44  }
45  return false;
46 }
47 
48 RZ_API const char *rz_reg_cond_to_string(int n) {
49  const char *cs[] = {
50  "eq", "ne", "cf", "neg", "of", "hi", "he",
51  "lo", "loe", "ge", "gt", "lt", "le"
52  };
53  if (n < 0 || (n > (sizeof(cs) / sizeof(*cs)) - 1)) {
54  return NULL;
55  }
56  return cs[n];
57 }
58 
60  if (!strcmp(str, "eq")) {
61  return RZ_REG_COND_EQ;
62  }
63  if (!strcmp(str, "ne")) {
64  return RZ_REG_COND_NE;
65  }
66  if (!strcmp(str, "cf")) {
67  return RZ_REG_COND_CF;
68  }
69  if (!strcmp(str, "neg")) {
70  return RZ_REG_COND_NEG;
71  }
72  if (!strcmp(str, "of")) {
73  return RZ_REG_COND_OF;
74  }
75  if (!strcmp(str, "hi")) {
76  return RZ_REG_COND_HI;
77  }
78  if (!strcmp(str, "he")) {
79  return RZ_REG_COND_HE;
80  }
81  if (!strcmp(str, "lo")) {
82  return RZ_REG_COND_LO;
83  }
84  if (!strcmp(str, "loe")) {
85  return RZ_REG_COND_LOE;
86  }
87  if (!strcmp(str, "ge")) {
88  return RZ_REG_COND_GE;
89  }
90  if (!strcmp(str, "gt")) {
91  return RZ_REG_COND_GT;
92  }
93  if (!strcmp(str, "lt")) {
94  return RZ_REG_COND_LT;
95  }
96  if (!strcmp(str, "le")) {
97  return RZ_REG_COND_LE;
98  }
99  return -1;
100 }
101 
103  switch (type) {
104  case RZ_REG_COND_EQ: return Z;
105  case RZ_REG_COND_NE: return !Z;
106  case RZ_REG_COND_CF: return C;
107  case RZ_REG_COND_NEG: return S;
108  case RZ_REG_COND_OF:
109  return O;
110  // unsigned
111  case RZ_REG_COND_HI: return (!Z && C); // HIGHER
112  case RZ_REG_COND_HE: return Z || (!Z && C); // HIGHER OR EQUAL
113  case RZ_REG_COND_LO: return (Z || !C); // LOWER
114  case RZ_REG_COND_LOE:
115  return (Z || !C); // LOWER OR EQUAL
116  // signed
117  case RZ_REG_COND_GE: return ((S && O) || (!S && !O));
118  case RZ_REG_COND_GT: return ((S && !Z && O) || (!S && !Z && !O));
119  case RZ_REG_COND_LT: return ((S && !O) || (!S && O));
120  case RZ_REG_COND_LE: return (Z || (S && !O) || (!S && O));
121  }
122  return false;
123 }
124 
126  switch (type) {
127  case RZ_REG_COND_EQ: Z = v; break;
128  case RZ_REG_COND_NE: Z = !v; break;
129  case RZ_REG_COND_CF: C = v; break;
130  case RZ_REG_COND_NEG: S = v; break;
131  case RZ_REG_COND_OF: O = v; break;
132  case RZ_REG_COND_HI:
133  if (v) {
134  Z = 0;
135  C = 1;
136  } else {
137  Z = 1;
138  C = 0;
139  }
140  break;
141  case RZ_REG_COND_HE:
142  if (v) {
143  Z = 1;
144  } else {
145  Z = 0;
146  C = 1;
147  }
148  break;
149  case RZ_REG_COND_LO:
150  if (v) {
151  Z = 1;
152  C = 0;
153  } else {
154  Z = 0;
155  C = 1;
156  }
157  break;
158  case RZ_REG_COND_LOE:
159  if (v) {
160  Z = 1;
161  C = 0;
162  } else {
163  Z = 0;
164  C = 1;
165  }
166  break;
167  // signed
168  case RZ_REG_COND_GE:
169  if (v) {
170  S = O = 1;
171  } else {
172  S = 1;
173  O = 0;
174  }
175  break;
176  case RZ_REG_COND_GT:
177  if (v) {
178  S = 1;
179  Z = 0;
180  O = 1;
181  } else {
182  S = 0;
183  Z = 1;
184  O = 0;
185  }
186  break;
187  case RZ_REG_COND_LT:
188  if (v) {
189  S = 1;
190  O = 0;
191  } else {
192  S = 1;
193  O = 1;
194  }
195  break;
196  case RZ_REG_COND_LE:
197  if (v) {
198  S = 0;
199  Z = 1;
200  O = 0;
201  } else {
202  S = 1;
203  Z = 0;
204  O = 1;
205  }
206  break;
207  default:
208  return false;
209  }
210  return true;
211 }
212 
214  RzRegFlags f = { 0 };
216  return rz_reg_cond_bits(r, type, &f);
217 }
218 
220  if (!f) {
221  f = RZ_NEW0(RzRegFlags);
222  }
223  if (!f) {
224  return NULL;
225  }
226  f->s = rz_reg_cond_get_value(r, "sign"); // sign, negate flag, less than zero
227  f->z = rz_reg_cond_get_value(r, "zero"); // zero flag
228  f->c = rz_reg_cond_get_value(r, "carry"); // carry flag
229  f->o = rz_reg_cond_get_value(r, "overflow"); // overflow flag
230  f->p = rz_reg_cond_get_value(r, "parity"); // parity // intel only
231  return f;
232 }
233 
235  rz_return_if_fail(r && f);
236  rz_reg_cond_set(r, "sign", f->s);
237  rz_reg_cond_set(r, "zero", f->z);
238  rz_reg_cond_set(r, "carry", f->c);
239  rz_reg_cond_set(r, "overflow", f->o);
240  rz_reg_cond_set(r, "parity", f->p);
241 }
lzma_index ** i
Definition: index.h:629
ut16 val
Definition: armass64_const.h:6
#define RZ_API
#define NULL
Definition: cris-opc.c:27
#define r
Definition: crypto_rc6.c:12
const char * v
Definition: dsignal.c:12
#define reg(n)
int n
Definition: mipsasm.c:19
int type
Definition: mipsasm.c:17
RZ_API bool rz_reg_cond_set(RzReg *r, const char *name, bool val)
Definition: rcond.c:39
RZ_API bool rz_reg_cond_bits_set(RzReg *r, int type, RzRegFlags *f, bool v)
Definition: rcond.c:125
RZ_API int rz_reg_cond_bits(RzReg *r, int type, RzRegFlags *f)
Definition: rcond.c:102
RZ_API void rz_reg_cond_apply(RzReg *r, RzRegFlags *f)
Definition: rcond.c:234
#define O
Definition: rcond.c:14
RZ_API int rz_reg_cond_from_string(const char *str)
Definition: rcond.c:59
#define Z
Definition: rcond.c:11
RZ_API int rz_reg_cond_get_value(RzReg *r, const char *name)
Definition: rcond.c:31
RZ_API RzRegFlags * rz_reg_cond_retrieve(RzReg *r, RzRegFlags *f)
Definition: rcond.c:219
RZ_API RzRegItem * rz_reg_cond_get(RzReg *reg, const char *name)
Definition: rcond.c:17
#define C
Definition: rcond.c:13
RZ_API const char * rz_reg_cond_to_string(int n)
Definition: rcond.c:48
RZ_API int rz_reg_cond(RzReg *r, int type)
Definition: rcond.c:213
#define S
Definition: rcond.c:12
RZ_API bool rz_reg_set_value(RzReg *reg, RzRegItem *item, ut64 value)
Definition: rvalue.c:186
RZ_API ut64 rz_reg_get_value(RzReg *reg, RzRegItem *item)
Definition: rvalue.c:114
#define rz_return_if_fail(expr)
Definition: rz_assert.h:100
#define rz_return_val_if_fail(expr, val)
Definition: rz_assert.h:108
#define RZ_REG_COND_NE
Definition: rz_reg.h:76
@ RZ_REG_TYPE_GPR
Definition: rz_reg.h:21
#define RZ_REG_COND_GT
Definition: rz_reg.h:90
#define RZ_REG_COND_LO
Definition: rz_reg.h:86
#define RZ_REG_COND_OF
Definition: rz_reg.h:81
#define RZ_REG_COND_HI
Definition: rz_reg.h:84
#define RZ_REG_COND_EQ
Definition: rz_reg.h:75
#define RZ_REG_COND_LE
Definition: rz_reg.h:92
#define RZ_REG_COND_CF
Definition: rz_reg.h:77
#define RZ_REG_COND_GE
Definition: rz_reg.h:89
#define RZ_REG_COND_NEG
Definition: rz_reg.h:79
#define RZ_REG_COND_HE
Definition: rz_reg.h:85
#define RZ_REG_COND_LOE
Definition: rz_reg.h:87
#define RZ_REG_COND_LT
Definition: rz_reg.h:91
#define RZ_NEW0(x)
Definition: rz_types.h:284
#define f(i)
Definition: sha256.c:46
Definition: z80asm.h:102