Debian Codegraph @

libdrgn/object.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <assert.h>
5 #include <inttypes.h>
6 #include <limits.h>
7 #include <stdlib.h>
8 #include <string.h>
9
10 #include "cleanup.h"
11 #include "drgn_internal.h"
12 #include "error.h"
13 #include "language.h"
14 #include "minmax.h"
15 #include "object.h"
16 #include "program.h"
17 #include "serialize.h"
18 #include "type.h"
19 #include "util.h"
20
21 #define DRGN_OBJECT_INITIALIZER(prog) \
22 (struct drgn_object){ \
23 .type = &(prog)->void_types[DRGN_LANGUAGE_C], \
24 .encoding = DRGN_OBJECT_ENCODING_NONE, \
25 .kind = DRGN_OBJECT_ABSENT, \
26 .absence_reason = DRGN_ABSENCE_REASON_OTHER, \
27 }
28
29 LIBDRGN_PUBLIC
30 struct drgn_object drgn_object_initializer(struct drgn_program *prog)
31 {
32 return DRGN_OBJECT_INITIALIZER(prog);
33 }
34
35 LIBDRGN_PUBLIC void drgn_object_init(struct drgn_object *obj,
36 struct drgn_program *prog)
37 {
38 *obj = DRGN_OBJECT_INITIALIZER(prog);
39 }
40
41 static void drgn_value_deinit(const struct drgn_object *obj,
42 const union drgn_value *value)
43 {
44 if ((obj->encoding == DRGN_OBJECT_ENCODING_BUFFER
45 && !drgn_object_is_inline(obj))
46 || obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
47 || obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG)
48 free(value->bufp);
49 }
50
51 LIBDRGN_PUBLIC void drgn_object_deinit_value(const struct drgn_object *obj,
52 const union drgn_value *value)
53 {
54 if (value != &obj->value)
55 drgn_value_deinit(obj, value);
56 }
57
58 LIBDRGN_PUBLIC void drgn_object_deinit(struct drgn_object *obj)
59 {
60 if (obj->kind == DRGN_OBJECT_VALUE)
61 drgn_value_deinit(obj, &obj->value);
62 }
63
64 /* Copy everything from src to dst but the kind and value. */
65 static inline void drgn_object_reinit_copy(struct drgn_object *dst,
66 const struct drgn_object *src)
67 {
68 drgn_object_deinit(dst);
69 dst->type = src->type;
70 dst->qualifiers = src->qualifiers;
71 dst->encoding = src->encoding;
72 dst->bit_size = src->bit_size;
73 dst->is_bit_field = src->is_bit_field;
74 dst->little_endian = src->little_endian;
75 }
76
77 static struct drgn_error *
78 drgn_object_type_impl(struct drgn_type *type, struct drgn_type *underlying_type,
79 enum drgn_qualifiers qualifiers, uint64_t bit_field_size,
80 struct drgn_object_type *ret)
81 {
82 struct drgn_error *err;
83
84 ret->type = type;
85 ret->underlying_type = underlying_type;
86 ret->qualifiers = qualifiers;
87
88 if (drgn_type_is_complete(underlying_type)
89 && drgn_type_kind(underlying_type) != DRGN_TYPE_FUNCTION) {
90 err = drgn_type_bit_size(type, &ret->bit_size);
91 if (err)
92 return err;
93 } else {
94 ret->bit_size = 0;
95 }
96
97 struct drgn_type *compatible_type = underlying_type;
98 SWITCH_ENUM(drgn_type_kind(compatible_type)) {
99 case DRGN_TYPE_ENUM:
100 if (!drgn_type_is_complete(compatible_type)) {
101 ret->encoding = DRGN_OBJECT_ENCODING_INCOMPLETE_INTEGER;
102 break;
103 }
104 compatible_type = drgn_type_type(compatible_type).type;
105 fallthrough;
106 case DRGN_TYPE_INT:
107 case DRGN_TYPE_BOOL: {
108 if (bit_field_size != 0) {
109 if (bit_field_size > ret->bit_size) {
110 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
111 "bit field size is larger than type size");
112 }
113 ret->bit_size = bit_field_size;
114 }
115 // The maximum bit size we can represent is UINT64_MAX. However,
116 // pick an arbitrary smaller limit to keep things from getting
117 // out of hand: 2^24 is the maximum bit width that Clang 13
118 // allows for _ExtInt() (limited by the LLVM IR representation;
119 // technically it's 2^24-1, but it gets rounded up to a
120 // DW_AT_byte_size of 2^24/8).
121 if (ret->bit_size < 1 || ret->bit_size > 16777216) {
122 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
123 "unsupported integer bit size (%" PRIu64 ")",
124 ret->bit_size);
125 }
126 bool is_signed =
127 drgn_type_kind(compatible_type) == DRGN_TYPE_INT
128 && drgn_type_is_signed(compatible_type);
129 if (ret->bit_size <= 64 && is_signed)
130 ret->encoding = DRGN_OBJECT_ENCODING_SIGNED;
131 else if (ret->bit_size <= 64)
132 ret->encoding = DRGN_OBJECT_ENCODING_UNSIGNED;
133 else if (is_signed)
134 ret->encoding = DRGN_OBJECT_ENCODING_SIGNED_BIG;
135 else
136 ret->encoding = DRGN_OBJECT_ENCODING_UNSIGNED_BIG;
137 break;
138 }
139 case DRGN_TYPE_POINTER:
140 ret->encoding = DRGN_OBJECT_ENCODING_UNSIGNED;
141 break;
142 case DRGN_TYPE_FLOAT:
143 if (ret->bit_size < 1 || ret->bit_size > 256) {
144 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
145 "unsupported floating-point bit size (%" PRIu64 ")",
146 ret->bit_size);
147 }
148 ret->encoding = DRGN_OBJECT_ENCODING_FLOAT;
149 break;
150 case DRGN_TYPE_STRUCT:
151 case DRGN_TYPE_UNION:
152 case DRGN_TYPE_CLASS:
153 case DRGN_TYPE_ARRAY:
154 if (drgn_type_is_complete(compatible_type))
155 ret->encoding = DRGN_OBJECT_ENCODING_BUFFER;
156 else
157 ret->encoding = DRGN_OBJECT_ENCODING_INCOMPLETE_BUFFER;
158 break;
159 case DRGN_TYPE_VOID:
160 case DRGN_TYPE_FUNCTION:
161 ret->encoding = DRGN_OBJECT_ENCODING_NONE;
162 break;
163 // This is already the underlying type, so it can't be a typedef.
164 case DRGN_TYPE_TYPEDEF:
165 default:
166 UNREACHABLE();
167 }
168
169 if (bit_field_size != 0
170 && drgn_type_kind(compatible_type) != DRGN_TYPE_INT
171 && drgn_type_kind(compatible_type) != DRGN_TYPE_BOOL) {
172 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
173 "bit field must be integer");
174 }
175 ret->is_bit_field = bit_field_size != 0;
176
177 ret->little_endian = (drgn_type_has_little_endian(compatible_type)
178 && drgn_type_little_endian(compatible_type));
179 return NULL;
180 }
181
182 struct drgn_error *
183 drgn_object_type(struct drgn_qualified_type qualified_type,
184 uint64_t bit_field_size, struct drgn_object_type *ret)
185 {
186 return drgn_object_type_impl(qualified_type.type,
187 drgn_underlying_type(qualified_type.type),
188 qualified_type.qualifiers, bit_field_size,
189 ret);
190 }
191
192 static struct drgn_error *
193 drgn_object_type_operand(const struct drgn_operand_type *op_type,
194 struct drgn_object_type *ret)
195 {
196 struct drgn_error *err;
197 err = drgn_object_type_impl(op_type->type, op_type->underlying_type,
198 op_type->qualifiers,
199 op_type->bit_field_size, ret);
200 if (err)
201 return err;
202 if (ret->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
203 || ret->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
204 return drgn_error_create(DRGN_ERROR_NOT_IMPLEMENTED,
205 "operations on integer values larger than 64 bits are not yet supported");
206 }
207 return NULL;
208 }
209
210 struct drgn_error *
211 drgn_object_set_signed_internal(struct drgn_object *res,
212 const struct drgn_object_type *type,
213 int64_t svalue)
214 {
215 if (type->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG) {
216 uint64_t size = drgn_value_size(type->bit_size);
217 void *buf = malloc64(size);
218 if (!buf)
219 return &drgn_enomem;
220 copy_lsbytes_fill(buf, size, type->little_endian, &svalue,
221 sizeof(svalue), HOST_LITTLE_ENDIAN,
222 svalue < 0 ? -1 : 0);
223 drgn_object_reinit(res, type, DRGN_OBJECT_VALUE);
224 res->value.bufp = buf;
225 return NULL;
226 }
227 drgn_object_reinit(res, type, DRGN_OBJECT_VALUE);
228 res->value.svalue = truncate_signed(svalue, type->bit_size);
229 return NULL;
230 }
231
232 LIBDRGN_PUBLIC struct drgn_error *
233 drgn_object_set_signed(struct drgn_object *res,
234 struct drgn_qualified_type qualified_type,
235 int64_t svalue, uint64_t bit_field_size)
236 {
237 struct drgn_error *err;
238 struct drgn_object_type type;
239 err = drgn_object_type(qualified_type, bit_field_size, &type);
240 if (err)
241 return err;
242 if (type.encoding != DRGN_OBJECT_ENCODING_SIGNED
243 && type.encoding != DRGN_OBJECT_ENCODING_SIGNED_BIG) {
244 return drgn_error_create(DRGN_ERROR_TYPE,
245 "not a signed integer type");
246 }
247 return drgn_object_set_signed_internal(res, &type, svalue);
248 }
249
250 struct drgn_error *
251 drgn_object_set_unsigned_internal(struct drgn_object *res,
252 const struct drgn_object_type *type,
253 uint64_t uvalue)
254 {
255 if (type->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
256 uint64_t size = drgn_value_size(type->bit_size);
257 void *buf = malloc64(size);
258 if (!buf)
259 return &drgn_enomem;
260 copy_lsbytes(buf, size, type->little_endian, &uvalue,
261 sizeof(uvalue), HOST_LITTLE_ENDIAN);
262 drgn_object_reinit(res, type, DRGN_OBJECT_VALUE);
263 res->value.bufp = buf;
264 return NULL;
265 }
266 drgn_object_reinit(res, type, DRGN_OBJECT_VALUE);
267 res->value.uvalue = truncate_unsigned(uvalue, type->bit_size);
268 return NULL;
269 }
270
271 LIBDRGN_PUBLIC struct drgn_error *
272 drgn_object_set_unsigned(struct drgn_object *res,
273 struct drgn_qualified_type qualified_type,
274 uint64_t uvalue, uint64_t bit_field_size)
275 {
276 struct drgn_error *err;
277 struct drgn_object_type type;
278 err = drgn_object_type(qualified_type, bit_field_size, &type);
279 if (err)
280 return err;
281 if (type.encoding != DRGN_OBJECT_ENCODING_UNSIGNED
282 && type.encoding != DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
283 return drgn_error_create(DRGN_ERROR_TYPE,
284 "not an unsigned integer type");
285 }
286 return drgn_object_set_unsigned_internal(res, &type, uvalue);
287 }
288
289 static struct drgn_error drgn_float_size_unsupported = {
290 .code = DRGN_ERROR_NOT_IMPLEMENTED,
291 .message = "float values which are not 32 or 64 bits are not yet supported",
292 };
293
294 struct drgn_error *
295 drgn_object_set_float_internal(struct drgn_object *res,
296 const struct drgn_object_type *type,
297 double fvalue)
298 {
299 if (type->bit_size != 32 && type->bit_size != 64)
300 return &drgn_float_size_unsupported;
301 drgn_object_reinit(res, type, DRGN_OBJECT_VALUE);
302 if (type->bit_size == 32)
303 res->value.fvalue = (float)fvalue;
304 else
305 res->value.fvalue = fvalue;
306 return NULL;
307 }
308
309 LIBDRGN_PUBLIC struct drgn_error *
310 drgn_object_set_float(struct drgn_object *res,
311 struct drgn_qualified_type qualified_type, double fvalue)
312 {
313 struct drgn_error *err;
314 struct drgn_object_type type;
315 err = drgn_object_type(qualified_type, 0, &type);
316 if (err)
317 return err;
318 if (type.encoding != DRGN_OBJECT_ENCODING_FLOAT) {
319 return drgn_error_create(DRGN_ERROR_TYPE,
320 "not a floating-point type");
321 }
322 return drgn_object_set_float_internal(res, &type, fvalue);
323 }
324
325 static void drgn_value_deserialize(union drgn_value *value, const void *buf,
326 uint8_t bit_offset,
327 enum drgn_object_encoding encoding,
328 uint64_t bit_size, bool little_endian)
329 {
330 union {
331 int64_t svalue;
332 uint64_t uvalue;
333 double fvalue64;
334 struct {
335 #if !HOST_LITTLE_ENDIAN
336 float pad;
337 #endif
338 float fvalue32;
339 };
340 } tmp;
341
342 tmp.uvalue = deserialize_bits(buf, bit_offset, bit_size, little_endian);
343 switch (encoding) {
344 case DRGN_OBJECT_ENCODING_SIGNED:
345 value->svalue = truncate_signed(tmp.svalue, bit_size);
346 break;
347 case DRGN_OBJECT_ENCODING_UNSIGNED:
348 value->uvalue = tmp.uvalue;
349 break;
350 case DRGN_OBJECT_ENCODING_FLOAT:
351 value->fvalue = bit_size == 32 ? tmp.fvalue32 : tmp.fvalue64;
352 break;
353 default:
354 UNREACHABLE();
355 }
356 }
357
358 struct drgn_error *
359 drgn_object_set_from_buffer_internal(struct drgn_object *res,
360 const struct drgn_object_type *type,
361 const void *buf, uint64_t bit_offset)
362 {
363 const char *p = (const char *)buf + (bit_offset / CHAR_BIT);
364 bit_offset %= CHAR_BIT;
365 /*
366 * buf may point inside of res->value or drgn_object_buffer(res), so we
367 * copy to a temporary value before freeing or modifying the old value.
368 */
369 union drgn_value value;
370 if (type->encoding == DRGN_OBJECT_ENCODING_BUFFER
371 || type->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
372 || type->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
373 if (type->encoding == DRGN_OBJECT_ENCODING_BUFFER
374 && bit_offset != 0) {
375 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
376 "non-scalar must be byte-aligned");
377 }
378 uint64_t size = drgn_value_size(type->bit_size);
379 void *dst;
380 if (size <= sizeof(res->value.ibuf)) {
381 dst = value.ibuf;
382 } else {
383 dst = malloc64(size);
384 if (!dst)
385 return &drgn_enomem;
386 value.bufp = dst;
387 }
388 if (size > 0) {
389 int dst_bit_offset = 0;
390 if (type->encoding != DRGN_OBJECT_ENCODING_BUFFER
391 && !type->little_endian)
392 dst_bit_offset = -type->bit_size % 8;
393 ((uint8_t *)dst)[0] = 0;
394 ((uint8_t *)dst)[size - 1] = 0;
395 copy_bits(dst, dst_bit_offset, p, bit_offset,
396 type->bit_size, type->little_endian);
397 if (type->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
398 && type->bit_size % 8 != 0) {
399 int8_t *dst_p;
400 if (type->little_endian)
401 dst_p = (int8_t *)dst + size - 1;
402 else
403 dst_p = (int8_t *)dst;
404 *dst_p = truncate_signed8(*dst_p, type->bit_size % 8);
405 }
406 }
407 } else if (drgn_object_encoding_is_complete(type->encoding)) {
408 if (type->encoding == DRGN_OBJECT_ENCODING_FLOAT
409 && type->bit_size != 32 && type->bit_size != 64)
410 return &drgn_float_size_unsupported;
411 drgn_value_deserialize(&value, p, bit_offset, type->encoding,
412 type->bit_size, type->little_endian);
413 } else {
414 return drgn_error_incomplete_type("cannot create object with %s type",
415 type->type);
416 }
417 drgn_object_reinit(res, type, DRGN_OBJECT_VALUE);
418 res->value = value;
419 return NULL;
420 }
421
422 LIBDRGN_PUBLIC struct drgn_error *
423 drgn_object_set_from_buffer(struct drgn_object *res,
424 struct drgn_qualified_type qualified_type,
425 const void *buf, size_t buf_size,
426 uint64_t bit_offset, uint64_t bit_field_size)
427 {
428 struct drgn_error *err;
429 struct drgn_object_type type;
430 err = drgn_object_type(qualified_type, bit_field_size, &type);
431 if (err)
432 return err;
433 if (type.bit_size > UINT64_MAX - bit_offset ||
434 buf_size < drgn_value_size(bit_offset + type.bit_size)) {
435 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
436 "buffer is too small");
437 }
438 return drgn_object_set_from_buffer_internal(res, &type, buf,
439 bit_offset);
440 }
441
442 struct drgn_error *
443 drgn_object_set_reference_internal(struct drgn_object *res,
444 const struct drgn_object_type *type,
445 uint64_t address, uint64_t bit_offset)
446 {
447 uint64_t address_mask;
448 struct drgn_error *err =
449 drgn_program_address_mask(drgn_object_program(res),
450 &address_mask);
451 if (err)
452 return err;
453
454 address += bit_offset / 8;
455 address &= address_mask;
456 bit_offset %= 8;
457 if (bit_offset != 0) {
458 SWITCH_ENUM(type->encoding) {
459 case DRGN_OBJECT_ENCODING_SIGNED:
460 case DRGN_OBJECT_ENCODING_UNSIGNED:
461 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
462 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG:
463 case DRGN_OBJECT_ENCODING_FLOAT:
464 case DRGN_OBJECT_ENCODING_INCOMPLETE_INTEGER:
465 break;
466 case DRGN_OBJECT_ENCODING_NONE:
467 case DRGN_OBJECT_ENCODING_BUFFER:
468 case DRGN_OBJECT_ENCODING_INCOMPLETE_BUFFER:
469 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
470 "non-scalar must be byte-aligned");
471 default:
472 UNREACHABLE();
473 }
474 }
475 if (type->bit_size > UINT64_MAX - bit_offset) {
476 return drgn_error_format(DRGN_ERROR_OVERFLOW,
477 "object is too large");
478 }
479
480 drgn_object_reinit(res, type, DRGN_OBJECT_REFERENCE);
481 res->address = address;
482 res->bit_offset = bit_offset;
483 return NULL;
484 }
485
486 LIBDRGN_PUBLIC struct drgn_error *
487 drgn_object_set_reference(struct drgn_object *res,
488 struct drgn_qualified_type qualified_type,
489 uint64_t address, uint64_t bit_offset,
490 uint64_t bit_field_size)
491 {
492 struct drgn_error *err;
493 struct drgn_object_type type;
494 err = drgn_object_type(qualified_type, bit_field_size, &type);
495 if (err)
496 return err;
497 return drgn_object_set_reference_internal(res, &type, address,
498 bit_offset);
499 }
500
501 LIBDRGN_PUBLIC struct drgn_error *
502 drgn_object_set_absent(struct drgn_object *res,
503 struct drgn_qualified_type qualified_type,
504 enum drgn_absence_reason reason,
505 uint64_t bit_field_size)
506 {
507 struct drgn_error *err;
508 struct drgn_object_type type;
509 err = drgn_object_type(qualified_type, bit_field_size, &type);
510 if (err)
511 return err;
512 drgn_object_set_absent_internal(res, &type, reason);
513 return NULL;
514 }
515
516 LIBDRGN_PUBLIC struct drgn_error *
517 drgn_object_copy(struct drgn_object *res, const struct drgn_object *obj)
518 {
519 if (res == obj)
520 return NULL;
521
522 if (drgn_object_program(res) != drgn_object_program(obj)) {
523 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
524 "objects are from different programs");
525 }
526
527 SWITCH_ENUM(obj->kind) {
528 case DRGN_OBJECT_VALUE:
529 if (obj->encoding == DRGN_OBJECT_ENCODING_BUFFER
530 || obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
531 || obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
532 size_t size = drgn_object_size(obj);
533 char *dst;
534 const char *src;
535 if (size <= sizeof(obj->value.ibuf)) {
536 dst = res->value.ibuf;
537 src = obj->value.ibuf;
538 } else {
539 dst = malloc(size);
540 if (!dst)
541 return &drgn_enomem;
542 src = obj->value.bufp;
543 }
544 drgn_object_reinit_copy(res, obj);
545 res->kind = DRGN_OBJECT_VALUE;
546 memcpy(dst, src, size);
547 if (dst != res->value.ibuf)
548 res->value.bufp = dst;
549 } else {
550 drgn_object_reinit_copy(res, obj);
551 res->kind = DRGN_OBJECT_VALUE;
552 res->value = obj->value;
553 }
554 break;
555 case DRGN_OBJECT_REFERENCE:
556 drgn_object_reinit_copy(res, obj);
557 res->kind = DRGN_OBJECT_REFERENCE;
558 res->address = obj->address;
559 res->bit_offset = obj->bit_offset;
560 break;
561 case DRGN_OBJECT_ABSENT:
562 drgn_object_reinit_copy(res, obj);
563 res->kind = DRGN_OBJECT_ABSENT;
564 break;
565 default:
566 UNREACHABLE();
567 }
568 return NULL;
569 }
570
571 struct drgn_error *
572 drgn_object_fragment_internal(struct drgn_object *res,
573 const struct drgn_object *obj,
574 const struct drgn_object_type *type,
575 int64_t bit_offset, uint64_t bit_field_size)
576 {
577 struct drgn_error *err;
578
579 SWITCH_ENUM(obj->kind) {
580 case DRGN_OBJECT_VALUE: {
581 uint64_t bit_end;
582 if (bit_offset < 0
583 || __builtin_add_overflow(bit_offset, type->bit_size,
584 &bit_end)
585 || bit_end > obj->bit_size) {
586 return drgn_error_create(DRGN_ERROR_OUT_OF_BOUNDS,
587 "out of bounds of value");
588 }
589 char small_buf[8];
590 const void *buf;
591 _cleanup_free_ char *free_buf = NULL;
592 if (obj->encoding == DRGN_OBJECT_ENCODING_BUFFER) {
593 buf = drgn_object_buffer(obj);
594 } else {
595 size_t size = drgn_object_size(obj);
596 if (size <= sizeof(small_buf)) {
597 buf = small_buf;
598 } else {
599 buf = free_buf = malloc(size);
600 if (!buf)
601 return &drgn_enomem;
602 }
603 err = drgn_object_read_bytes(obj, (void *)buf);
604 if (err)
605 return err;
606 }
607 return drgn_object_set_from_buffer_internal(res, type, buf,
608 bit_offset);
609 }
610 case DRGN_OBJECT_REFERENCE: {
611 // obj->bit_offset + bit_offset can overflow, so apply the
612 // byte-aligned part of bit_offset now.
613 //
614 // / and % truncate towards 0. Here, we want to truncate towards
615 // negative infinity. We can accomplish that by replacing "/ 8"
616 // with an arithmetic shift ">> 3" and "% 8" with "& 7".
617 uint64_t address = obj->address + (bit_offset >> 3);
618 bit_offset &= 7;
619 return drgn_object_set_reference_internal(res, type, address,
620 obj->bit_offset
621 + bit_offset);
622 }
623 case DRGN_OBJECT_ABSENT:
624 return &drgn_error_object_absent;
625 default:
626 UNREACHABLE();
627 }
628 }
629
630 LIBDRGN_PUBLIC struct drgn_error *
631 drgn_object_fragment(struct drgn_object *res, const struct drgn_object *obj,
632 struct drgn_qualified_type qualified_type,
633 int64_t bit_offset, uint64_t bit_field_size)
634 {
635 struct drgn_error *err;
636 if (drgn_object_program(res) != drgn_object_program(obj)) {
637 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
638 "objects are from different programs");
639 }
640 struct drgn_object_type type;
641 err = drgn_object_type(qualified_type, bit_field_size, &type);
642 if (err)
643 return err;
644 return drgn_object_fragment_internal(res, obj, &type, bit_offset,
645 bit_field_size);
646 }
647
648 LIBDRGN_PUBLIC struct drgn_error *
649 drgn_object_dereference_offset(struct drgn_object *res,
650 const struct drgn_object *obj,
651 struct drgn_qualified_type qualified_type,
652 int64_t bit_offset, uint64_t bit_field_size)
653 {
654 struct drgn_error *err;
655 uint64_t address;
656
657 err = drgn_object_read_unsigned(obj, &address);
658 if (err)
659 return err;
660
661 /*
662 * / and % truncate towards 0. Here, we want to truncate towards
663 * negative infinity. We can accomplish that by replacing "/ 8" with an
664 * arithmetic shift ">> 3" and "% 8" with "& 7".
665 */
666 address += bit_offset >> 3;
667 bit_offset &= 7;
668 return drgn_object_set_reference(res, qualified_type, address,
669 bit_offset, bit_field_size);
670 }
671
672 static struct drgn_error *
673 drgn_object_read_reference(const struct drgn_object *obj,
674 union drgn_value *value)
675 {
676 struct drgn_error *err;
677
678 assert(obj->kind == DRGN_OBJECT_REFERENCE);
679
680 if (!drgn_object_encoding_is_complete(obj->encoding)) {
681 return drgn_error_incomplete_type("cannot read object with %s type",
682 obj->type);
683 }
684
685 if (obj->encoding == DRGN_OBJECT_ENCODING_BUFFER
686 || obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
687 || obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
688 int dst_bit_offset = 0;
689 if (obj->encoding != DRGN_OBJECT_ENCODING_BUFFER
690 && !obj->little_endian)
691 dst_bit_offset = -obj->bit_size % 8;
692
693 uint64_t size = drgn_object_size(obj);
694 void *dst;
695 if (obj->bit_offset == 0 && dst_bit_offset == 0) {
696 if (size <= sizeof(value->ibuf)) {
697 dst = value->ibuf;
698 } else {
699 dst = malloc64(size);
700 if (!dst)
701 return &drgn_enomem;
702 }
703 err = drgn_program_read_memory(drgn_object_program(obj),
704 dst, obj->address, size,
705 false);
706 if (err) {
707 if (dst != value->ibuf)
708 free(dst);
709 return err;
710 }
711 if (obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG
712 && obj->bit_size % 8 != 0) {
713 // dst_bit_offset == 0 && obj->bit_size % 8 != 0
714 // implies obj->little_endian.
715 uint8_t *p = (uint8_t *)dst + size - 1;
716 *p = truncate_unsigned8(*p, obj->bit_size % 8);
717 }
718 } else {
719 // bit_offset + bit_size is guaranteed not to overflow
720 // because bit_offset can only be non-zero for
721 // SIGNED_BIG and UNSIGNED_BIG, which we limit to a
722 // reasonable bit_size.
723 uint64_t read_size =
724 drgn_value_size(obj->bit_offset + obj->bit_size);
725
726 // We could probably read directly into dst and move the
727 // bits in place if we really wanted to, but this is
728 // easier.
729 _cleanup_free_ void *tmp = malloc64(read_size);
730 if (!tmp)
731 return &drgn_enomem;
732 err = drgn_program_read_memory(drgn_object_program(obj),
733 tmp, obj->address,
734 read_size, false);
735 if (err)
736 return err;
737 if (size <= sizeof(value->ibuf)) {
738 dst = value->ibuf;
739 } else {
740 dst = malloc64(size);
741 if (!dst)
742 return &drgn_enomem;
743 }
744 ((uint8_t *)dst)[0] = 0;
745 ((uint8_t *)dst)[size - 1] = 0;
746 copy_bits(dst, dst_bit_offset, tmp, obj->bit_offset,
747 obj->bit_size, obj->little_endian);
748 }
749 if (obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
750 && obj->bit_size % 8 != 0) {
751 int8_t *p;
752 if (obj->little_endian)
753 p = (int8_t *)dst + size - 1;
754 else
755 p = (int8_t *)dst;
756 *p = truncate_signed8(*p, obj->bit_size % 8);
757 }
758 if (size > sizeof(value->ibuf))
759 value->bufp = dst;
760 return NULL;
761 } else {
762 uint64_t bit_size = obj->bit_size;
763 if (obj->encoding == DRGN_OBJECT_ENCODING_FLOAT
764 && bit_size != 32 && bit_size != 64)
765 return &drgn_float_size_unsupported;
766 uint8_t bit_offset = obj->bit_offset;
767 uint64_t read_size = drgn_value_size(bit_offset + bit_size);
768 char buf[9];
769 assert(read_size <= sizeof(buf));
770 err = drgn_program_read_memory(drgn_object_program(obj), buf,
771 obj->address, read_size, false);
772 if (err)
773 return err;
774 drgn_value_deserialize(value, buf, bit_offset, obj->encoding,
775 bit_size, obj->little_endian);
776 return NULL;
777 }
778 }
779
780 LIBDRGN_PUBLIC struct drgn_error *
781 drgn_object_read(struct drgn_object *res, const struct drgn_object *obj)
782 {
783 struct drgn_error *err;
784
785 SWITCH_ENUM(obj->kind) {
786 case DRGN_OBJECT_VALUE:
787 return drgn_object_copy(res, obj);
788 case DRGN_OBJECT_REFERENCE: {
789 if (drgn_object_program(res) != drgn_object_program(obj)) {
790 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
791 "objects are from different programs");
792 }
793 union drgn_value value;
794 err = drgn_object_read_reference(obj, &value);
795 if (err)
796 return err;
797 drgn_object_reinit_copy(res, obj);
798 res->kind = DRGN_OBJECT_VALUE;
799 res->value = value;
800 return NULL;
801 }
802 case DRGN_OBJECT_ABSENT:
803 return &drgn_error_object_absent;
804 default:
805 UNREACHABLE();
806 }
807 }
808
809 LIBDRGN_PUBLIC struct drgn_error *
810 drgn_object_read_value(const struct drgn_object *obj, union drgn_value *value,
811 const union drgn_value **ret)
812 {
813 struct drgn_error *err;
814
815 SWITCH_ENUM(obj->kind) {
816 case DRGN_OBJECT_VALUE:
817 *ret = &obj->value;
818 return NULL;
819 case DRGN_OBJECT_REFERENCE:
820 err = drgn_object_read_reference(obj, value);
821 if (!err)
822 *ret = value;
823 return err;
824 case DRGN_OBJECT_ABSENT:
825 return &drgn_error_object_absent;
826 default:
827 UNREACHABLE();
828 }
829 }
830
831 LIBDRGN_PUBLIC struct drgn_error *
832 drgn_object_read_bytes(const struct drgn_object *obj, void *buf)
833 {
834 struct drgn_error *err;
835
836 if (!drgn_object_encoding_is_complete(obj->encoding)) {
837 return drgn_error_incomplete_type("cannot read object with %s type",
838 obj->type);
839 }
840
841 SWITCH_ENUM(obj->kind) {
842 case DRGN_OBJECT_VALUE:
843 if (obj->encoding == DRGN_OBJECT_ENCODING_BUFFER
844 || obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
845 || obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
846 if (obj->bit_size % 8 == 0) {
847 memcpy(buf, drgn_object_buffer(obj),
848 drgn_object_size(obj));
849 } else {
850 int bit_offset = 0;
851 if (obj->encoding != DRGN_OBJECT_ENCODING_BUFFER
852 && !obj->little_endian)
853 bit_offset = -obj->bit_size % 8;
854 ((uint8_t *)buf)[drgn_object_size(obj) - 1] = 0;
855 copy_bits(buf, 0, drgn_object_buffer(obj),
856 bit_offset, obj->bit_size,
857 obj->little_endian);
858 }
859 } else {
860 union {
861 uint64_t uvalue;
862 struct {
863 #if !HOST_LITTLE_ENDIAN
864 uint32_t pad;
865 #endif
866 float fvalue32;
867 #if HOST_LITTLE_ENDIAN
868 uint32_t pad;
869 #endif
870 };
871 } tmp;
872 ((uint8_t *)buf)[drgn_object_size(obj) - 1] = 0;
873 if (obj->encoding == DRGN_OBJECT_ENCODING_FLOAT &&
874 obj->bit_size == 32) {
875 tmp.fvalue32 = (float)obj->value.fvalue;
876 tmp.pad = 0;
877 } else {
878 tmp.uvalue = obj->value.uvalue;
879 }
880 serialize_bits(buf, 0,
881 truncate_unsigned(tmp.uvalue, obj->bit_size),
882 obj->bit_size, obj->little_endian);
883 }
884 return NULL;
885 case DRGN_OBJECT_REFERENCE: {
886 uint64_t size = drgn_object_size(obj);
887 if (obj->bit_offset == 0) {
888 err = drgn_program_read_memory(drgn_object_program(obj),
889 buf, obj->address, size,
890 false);
891 if (err)
892 return err;
893 if (obj->bit_size % 8 != 0) {
894 uint8_t *p = (uint8_t *)buf + size - 1;
895 if (obj->little_endian)
896 *p = truncate_unsigned8(*p, obj->bit_size % 8);
897 else
898 *p &= 0xff00U >> (obj->bit_size % 8);
899 }
900 } else {
901 uint64_t read_size =
902 drgn_value_size(obj->bit_offset + obj->bit_size);
903
904 void *tmp;
905 char tmp_small[9];
906 _cleanup_free_ void *tmp_large = NULL;
907 if (read_size > sizeof(tmp_small)) {
908 tmp_large = malloc64(read_size);
909 if (!tmp_large)
910 return &drgn_enomem;
911 tmp = tmp_large;
912 } else {
913 tmp = tmp_small;
914 }
915 err = drgn_program_read_memory(drgn_object_program(obj),
916 tmp, obj->address,
917 read_size, false);
918 if (err)
919 return err;
920 ((uint8_t *)buf)[size - 1] = 0;
921 copy_bits(buf, 0, tmp, obj->bit_offset, obj->bit_size,
922 obj->little_endian);
923 }
924 return NULL;
925 }
926 case DRGN_OBJECT_ABSENT:
927 return &drgn_error_object_absent;
928 default:
929 UNREACHABLE();
930 }
931 }
932
933 static struct drgn_error *
934 drgn_object_value_signed(const struct drgn_object *obj, int64_t *ret)
935 {
936 struct drgn_error *err;
937 union drgn_value value_mem;
938 const union drgn_value *value;
939
940 assert(obj->encoding == DRGN_OBJECT_ENCODING_SIGNED);
941
942 err = drgn_object_read_value(obj, &value_mem, &value);
943 if (err)
944 return err;
945 *ret = value->svalue;
946 drgn_object_deinit_value(obj, value);
947 return err;
948 }
949
950 static struct drgn_error *
951 drgn_object_value_unsigned(const struct drgn_object *obj, uint64_t *ret)
952 {
953 struct drgn_error *err;
954 union drgn_value value_mem;
955 const union drgn_value *value;
956
957 assert(obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED);
958
959 err = drgn_object_read_value(obj, &value_mem, &value);
960 if (err)
961 return err;
962 *ret = value->uvalue;
963 drgn_object_deinit_value(obj, value);
964 return err;
965 }
966
967 static struct drgn_error *
968 drgn_object_value_float(const struct drgn_object *obj, double *ret)
969 {
970 struct drgn_error *err;
971 union drgn_value value_mem;
972 const union drgn_value *value;
973
974 assert(obj->encoding == DRGN_OBJECT_ENCODING_FLOAT);
975
976 err = drgn_object_read_value(obj, &value_mem, &value);
977 if (err)
978 return err;
979 *ret = value->fvalue;
980 drgn_object_deinit_value(obj, value);
981 return err;
982 }
983
984 static struct drgn_error drgn_integer_too_big = {
985 .code = DRGN_ERROR_OVERFLOW,
986 .message = "integer type is too big",
987 };
988
989 LIBDRGN_PUBLIC struct drgn_error *
990 drgn_object_read_signed(const struct drgn_object *obj, int64_t *ret)
991 {
992 if (obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG) {
993 return &drgn_integer_too_big;
994 } else if (obj->encoding != DRGN_OBJECT_ENCODING_SIGNED) {
995 return drgn_error_create(DRGN_ERROR_TYPE,
996 "not a signed integer");
997 }
998 return drgn_object_value_signed(obj, ret);
999 }
1000
1001 LIBDRGN_PUBLIC struct drgn_error *
1002 drgn_object_read_unsigned(const struct drgn_object *obj, uint64_t *ret)
1003 {
1004 if (obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG) {
1005 return &drgn_integer_too_big;
1006 } else if (obj->encoding != DRGN_OBJECT_ENCODING_UNSIGNED) {
1007 return drgn_error_create(DRGN_ERROR_TYPE,
1008 "not an unsigned integer");
1009 }
1010 return drgn_object_value_unsigned(obj, ret);
1011 }
1012
1013 LIBDRGN_PUBLIC struct drgn_error *
1014 drgn_object_read_integer(const struct drgn_object *obj, union drgn_value *ret)
1015 {
1016 struct drgn_error *err;
1017 union drgn_value value_mem;
1018 const union drgn_value *value;
1019
1020 if (obj->encoding == DRGN_OBJECT_ENCODING_SIGNED_BIG
1021 || obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED_BIG)
1022 return &drgn_integer_too_big;
1023 else if (obj->encoding != DRGN_OBJECT_ENCODING_SIGNED
1024 && obj->encoding != DRGN_OBJECT_ENCODING_UNSIGNED)
1025 return drgn_error_create(DRGN_ERROR_TYPE, "not an integer");
1026 err = drgn_object_read_value(obj, &value_mem, &value);
1027 if (err)
1028 return err;
1029 *ret = *value;
1030 drgn_object_deinit_value(obj, value);
1031 return NULL;
1032 }
1033
1034 LIBDRGN_PUBLIC struct drgn_error *
1035 drgn_object_read_float(const struct drgn_object *obj, double *ret)
1036 {
1037 if (obj->encoding != DRGN_OBJECT_ENCODING_FLOAT) {
1038 return drgn_error_create(DRGN_ERROR_TYPE,
1039 "not floating-point");
1040 }
1041 return drgn_object_value_float(obj, ret);
1042 }
1043
1044 LIBDRGN_PUBLIC struct drgn_error *
1045 drgn_object_read_c_string(const struct drgn_object *obj, char **ret)
1046 {
1047 struct drgn_error *err;
1048 struct drgn_type *underlying_type;
1049 uint64_t address;
1050 size_t max_size;
1051
1052 underlying_type = drgn_underlying_type(obj->type);
1053 switch (drgn_type_kind(underlying_type)) {
1054 case DRGN_TYPE_POINTER:
1055 err = drgn_object_value_unsigned(obj, &address);
1056 if (err)
1057 return err;
1058 max_size = SIZE_MAX;
1059 break;
1060 case DRGN_TYPE_ARRAY:
1061 if (drgn_type_is_complete(underlying_type)) {
1062 uint64_t size;
1063
1064 err = drgn_type_sizeof(underlying_type, &size);
1065 if (err)
1066 return err;
1067 max_size = min(size, (uint64_t)SIZE_MAX);
1068 } else {
1069 max_size = SIZE_MAX;
1070 }
1071 SWITCH_ENUM(obj->kind) {
1072 case DRGN_OBJECT_VALUE: {
1073 const char *buf;
1074 uint64_t value_size;
1075 size_t len;
1076 char *p, *str;
1077
1078 buf = drgn_object_buffer(obj);
1079 value_size = drgn_object_size(obj);
1080 len = min(value_size, (uint64_t)max_size);
1081 p = memchr(buf, 0, len);
1082 if (p)
1083 len = p - buf;
1084 str = malloc(len + 1);
1085 if (!str)
1086 return &drgn_enomem;
1087 memcpy(str, buf, len);
1088 str[len] = '\0';
1089 *ret = str;
1090 return NULL;
1091 }
1092 case DRGN_OBJECT_REFERENCE:
1093 address = obj->address;
1094 break;
1095 case DRGN_OBJECT_ABSENT:
1096 return &drgn_error_object_absent;
1097 default:
1098 UNREACHABLE();
1099 }
1100 break;
1101 default:
1102 return drgn_type_error("string() argument must be an array or pointer, not '%s'",
1103 obj->type);
1104 }
1105
1106 return drgn_program_read_c_string(drgn_object_program(obj), address,
1107 false, max_size, ret);
1108 }
1109
1110 LIBDRGN_PUBLIC struct drgn_error *
1111 drgn_format_object(const struct drgn_object *obj,
1112 const struct drgn_format_object_options *options,
1113 char **ret)
1114 {
1115
1116 const struct drgn_language *lang = drgn_object_language(obj);
1117
1118 if (options) {
1119 if (options->flags & ~DRGN_FORMAT_OBJECT_VALID_FLAGS) {
1120 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1121 "invalid format object flags");
1122 }
1123 if (options->integer_base != 8
1124 && options->integer_base != 10
1125 && options->integer_base != 16) {
1126 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1127 "invalid integer base");
1128 }
1129 } else {
1130 static const struct drgn_format_object_options default_options = {
1131 .columns = SIZE_MAX,
1132 .flags = DRGN_FORMAT_OBJECT_PRETTY,
1133 .integer_base = 10,
1134 };
1135 options = &default_options;
1136 }
1137 return lang->format_object(obj, options, ret);
1138 }
1139
1140 static struct drgn_error *
1141 drgn_object_convert_signed(const struct drgn_object *obj, uint64_t bit_size,
1142 int64_t *ret)
1143 {
1144 struct drgn_error *err;
1145 union drgn_value value_mem;
1146 const union drgn_value *value;
1147
1148 err = drgn_object_read_value(obj, &value_mem, &value);
1149 if (err)
1150 return err;
1151 switch (obj->encoding) {
1152 case DRGN_OBJECT_ENCODING_SIGNED:
1153 case DRGN_OBJECT_ENCODING_UNSIGNED:
1154 *ret = truncate_signed(value->svalue, bit_size);
1155 break;
1156 case DRGN_OBJECT_ENCODING_FLOAT:
1157 *ret = truncate_signed(value->fvalue, bit_size);
1158 break;
1159 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
1160 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG:
1161 return &drgn_integer_too_big;
1162 default:
1163 err = drgn_error_create(DRGN_ERROR_TYPE,
1164 "object cannot be converted to integer");
1165 break;
1166 }
1167 drgn_object_deinit_value(obj, value);
1168 return err;
1169 }
1170
1171 static struct drgn_error *
1172 drgn_object_convert_unsigned(const struct drgn_object *obj, uint64_t bit_size,
1173 uint64_t *ret)
1174 {
1175 struct drgn_error *err;
1176 union drgn_value value_mem;
1177 const union drgn_value *value;
1178
1179 err = drgn_object_read_value(obj, &value_mem, &value);
1180 if (err)
1181 return err;
1182 switch (obj->encoding) {
1183 case DRGN_OBJECT_ENCODING_SIGNED:
1184 case DRGN_OBJECT_ENCODING_UNSIGNED:
1185 *ret = truncate_unsigned(value->uvalue, bit_size);
1186 break;
1187 case DRGN_OBJECT_ENCODING_FLOAT:
1188 *ret = truncate_unsigned(value->fvalue, bit_size);
1189 break;
1190 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
1191 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG:
1192 return &drgn_integer_too_big;
1193 default:
1194 err = drgn_error_create(DRGN_ERROR_TYPE,
1195 "object cannot be converted to integer");
1196 break;
1197 }
1198 drgn_object_deinit_value(obj, value);
1199 return err;
1200 }
1201
1202 static struct drgn_error *
1203 drgn_object_convert_float(const struct drgn_object *obj, double *fvalue)
1204 {
1205 struct drgn_error *err;
1206 union drgn_value value_mem;
1207 const union drgn_value *value;
1208
1209 err = drgn_object_read_value(obj, &value_mem, &value);
1210 if (err)
1211 return err;
1212 switch (obj->encoding) {
1213 case DRGN_OBJECT_ENCODING_SIGNED:
1214 *fvalue = value->svalue;
1215 break;
1216 case DRGN_OBJECT_ENCODING_UNSIGNED:
1217 *fvalue = value->uvalue;
1218 break;
1219 case DRGN_OBJECT_ENCODING_FLOAT:
1220 *fvalue = value->fvalue;
1221 break;
1222 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
1223 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG:
1224 return &drgn_integer_too_big;
1225 default:
1226 err = drgn_error_create(DRGN_ERROR_TYPE,
1227 "object cannot be converted to floating-point");
1228 break;
1229 }
1230 drgn_object_deinit_value(obj, value);
1231 return err;
1232 }
1233
1234 static struct drgn_error *
1235 drgn_object_is_zero_impl(const struct drgn_object *obj, bool *ret);
1236
1237 static struct drgn_error *
1238 drgn_compound_object_is_zero(const struct drgn_object *obj,
1239 struct drgn_type *underlying_type, bool *ret)
1240 {
1241 struct drgn_error *err;
1242 struct drgn_type_member *members;
1243 size_t num_members, i;
1244
1245 DRGN_OBJECT(member, drgn_object_program(obj));
1246 members = drgn_type_members(underlying_type);
1247 num_members = drgn_type_num_members(underlying_type);
1248 for (i = 0; i < num_members; i++) {
1249 struct drgn_qualified_type member_type;
1250 uint64_t member_bit_field_size;
1251 err = drgn_member_type(&members[i], &member_type,
1252 &member_bit_field_size);
1253 if (err)
1254 return err;
1255
1256 err = drgn_object_fragment(&member, obj, member_type,
1257 members[i].bit_offset,
1258 member_bit_field_size);
1259 if (err)
1260 return err;
1261
1262 err = drgn_object_is_zero_impl(&member, ret);
1263 if (err || !*ret)
1264 return err;
1265 }
1266 return NULL;
1267 }
1268
1269 static struct drgn_error *
1270 drgn_array_object_is_zero(const struct drgn_object *obj,
1271 struct drgn_type *underlying_type, bool *ret)
1272 {
1273 struct drgn_error *err;
1274 struct drgn_qualified_type element_type;
1275 uint64_t element_bit_size, length, i;
1276
1277 element_type = drgn_type_type(underlying_type);
1278 err = drgn_type_bit_size(element_type.type, &element_bit_size);
1279 if (err)
1280 return err;
1281
1282 DRGN_OBJECT(element, drgn_object_program(obj));
1283 length = drgn_type_length(underlying_type);
1284 for (i = 0; i < length; i++) {
1285 err = drgn_object_fragment(&element, obj, element_type,
1286 i * element_bit_size, 0);
1287 if (err)
1288 return err;
1289
1290 err = drgn_object_is_zero_impl(&element, ret);
1291 if (err || !*ret)
1292 return err;
1293 }
1294 return NULL;
1295 }
1296
1297 static struct drgn_error *
1298 drgn_object_is_zero_impl(const struct drgn_object *obj, bool *ret)
1299 {
1300 struct drgn_error *err;
1301
1302 switch (obj->encoding) {
1303 case DRGN_OBJECT_ENCODING_SIGNED: {
1304 int64_t svalue;
1305
1306 err = drgn_object_value_signed(obj, &svalue);
1307 if (err)
1308 return err;
1309 if (svalue)
1310 *ret = false;
1311 return NULL;
1312 }
1313 case DRGN_OBJECT_ENCODING_UNSIGNED: {
1314 uint64_t uvalue;
1315
1316 err = drgn_object_value_unsigned(obj, &uvalue);
1317 if (err)
1318 return err;
1319 if (uvalue)
1320 *ret = false;
1321 return NULL;
1322 }
1323 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
1324 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG: {
1325 union drgn_value value_mem;
1326 const union drgn_value *value;
1327 err = drgn_object_read_value(obj, &value_mem, &value);
1328 if (err)
1329 return err;
1330 size_t size = drgn_object_size(obj);
1331 for (size_t i = 0; i < size; i++) {
1332 if (value->bufp[i] != 0) {
1333 *ret = false;
1334 break;
1335 }
1336 }
1337 drgn_object_deinit_value(obj, value);
1338 return NULL;
1339 }
1340 case DRGN_OBJECT_ENCODING_FLOAT: {
1341 double fvalue;
1342
1343 err = drgn_object_value_float(obj, &fvalue);
1344 if (err)
1345 return err;
1346 if (fvalue)
1347 *ret = false;
1348 return NULL;
1349 }
1350 case DRGN_OBJECT_ENCODING_BUFFER: {
1351 struct drgn_type *underlying_type;
1352
1353 underlying_type = drgn_underlying_type(obj->type);
1354 switch (drgn_type_kind(underlying_type)) {
1355 case DRGN_TYPE_STRUCT:
1356 case DRGN_TYPE_UNION:
1357 case DRGN_TYPE_CLASS:
1358 return drgn_compound_object_is_zero(obj,
1359 underlying_type,
1360 ret);
1361 case DRGN_TYPE_ARRAY:
1362 return drgn_array_object_is_zero(obj, underlying_type,
1363 ret);
1364 default:
1365 break;
1366 }
1367 fallthrough;
1368 }
1369 default:
1370 return drgn_error_create(DRGN_ERROR_TYPE,
1371 "object cannot be converted to boolean");
1372 }
1373 }
1374
1375 struct drgn_error *drgn_object_is_zero(const struct drgn_object *obj, bool *ret)
1376 {
1377 *ret = true;
1378 return drgn_object_is_zero_impl(obj, ret);
1379 }
1380
1381 LIBDRGN_PUBLIC struct drgn_error *
1382 drgn_object_cast(struct drgn_object *res,
1383 struct drgn_qualified_type qualified_type,
1384 const struct drgn_object *obj)
1385 {
1386 const struct drgn_language *lang = drgn_type_language(qualified_type.type);
1387
1388 if (drgn_object_program(res) != drgn_object_program(obj)) {
1389 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1390 "objects are from different programs");
1391 }
1392 return lang->op_cast(res, qualified_type, obj);
1393 }
1394
1395 LIBDRGN_PUBLIC struct drgn_error *
1396 drgn_object_implicit_convert(struct drgn_object *res,
1397 struct drgn_qualified_type qualified_type,
1398 uint64_t bit_field_size,
1399 const struct drgn_object *obj)
1400 {
1401 const struct drgn_language *lang = drgn_type_language(qualified_type.type);
1402
1403 if (drgn_object_program(res) != drgn_object_program(obj)) {
1404 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1405 "objects are from different programs");
1406 }
1407 return lang->op_implicit_convert(res, qualified_type, bit_field_size,
1408 obj);
1409 }
1410
1411 LIBDRGN_PUBLIC struct drgn_error *
1412 drgn_object_reinterpret(struct drgn_object *res,
1413 struct drgn_qualified_type qualified_type,
1414 const struct drgn_object *obj)
1415 {
1416 return drgn_object_fragment(res, obj, qualified_type, 0, 0);
1417 }
1418
1419 LIBDRGN_PUBLIC struct drgn_error *
1420 drgn_object_integer_literal(struct drgn_object *res, uint64_t uvalue)
1421 {
1422 const struct drgn_language *lang =
1423 drgn_program_language(drgn_object_program(res));
1424 return lang->integer_literal(res, uvalue);
1425 }
1426
1427 LIBDRGN_PUBLIC struct drgn_error *
1428 drgn_object_bool_literal(struct drgn_object *res, bool bvalue)
1429 {
1430 const struct drgn_language *lang =
1431 drgn_program_language(drgn_object_program(res));
1432 return lang->bool_literal(res, bvalue);
1433 }
1434
1435 LIBDRGN_PUBLIC struct drgn_error *
1436 drgn_object_float_literal(struct drgn_object *res, double fvalue)
1437 {
1438 const struct drgn_language *lang =
1439 drgn_program_language(drgn_object_program(res));
1440 return lang->float_literal(res, fvalue);
1441 }
1442
1443 LIBDRGN_PUBLIC struct drgn_error *
1444 drgn_object_bool(const struct drgn_object *obj, bool *ret)
1445 {
1446 const struct drgn_language *lang = drgn_object_language(obj);
1447
1448 return lang->op_bool(obj, ret);
1449 }
1450
1451 LIBDRGN_PUBLIC struct drgn_error *drgn_object_cmp(const struct drgn_object *lhs,
1452 const struct drgn_object *rhs,
1453 int *ret)
1454 {
1455 const struct drgn_language *lang = drgn_object_language(lhs);
1456 if (drgn_object_program(lhs) != drgn_object_program(rhs)) {
1457 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1458 "objects are from different programs");
1459 }
1460 return lang->op_cmp(lhs, rhs, ret);
1461 }
1462
1463 struct drgn_error *drgn_error_binary_op(const char *op_name,
1464 struct drgn_operand_type *lhs_type,
1465 struct drgn_operand_type *rhs_type)
1466 {
1467 struct drgn_error *err;
1468 _cleanup_free_ char *lhs_type_name = NULL;
1469 err = drgn_format_type_name(drgn_operand_type_qualified(lhs_type),
1470 &lhs_type_name);
1471 if (err)
1472 return err;
1473 _cleanup_free_ char *rhs_type_name = NULL;
1474 err = drgn_format_type_name(drgn_operand_type_qualified(rhs_type),
1475 &rhs_type_name);
1476 if (err)
1477 return err;
1478 return drgn_error_format(DRGN_ERROR_TYPE,
1479 "invalid operands to %s ('%s' and '%s')",
1480 op_name, lhs_type_name, rhs_type_name);
1481
1482 }
1483
1484 struct drgn_error *drgn_error_unary_op(const char *op_name,
1485 struct drgn_operand_type *type)
1486 {
1487 struct drgn_error *err;
1488 _cleanup_free_ char *type_name = NULL;
1489 err = drgn_format_type_name(drgn_operand_type_qualified(type),
1490 &type_name);
1491 if (err)
1492 return err;
1493 return drgn_error_format(DRGN_ERROR_TYPE,
1494 "invalid operand to %s ('%s')", op_name,
1495 type_name);
1496 }
1497
1498 #define BINARY_OP(op_name) \
1499 LIBDRGN_PUBLIC struct drgn_error * \
1500 drgn_object_##op_name(struct drgn_object *res, const struct drgn_object *lhs, \
1501 const struct drgn_object *rhs) \
1502 { \
1503 const struct drgn_language *lang = drgn_object_language(lhs); \
1504 \
1505 if (drgn_object_program(lhs) != drgn_object_program(res) || \
1506 drgn_object_program(rhs) != drgn_object_program(res)) { \
1507 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, \
1508 "objects are from different programs");\
1509 } \
1510 if (!lang->op_##op_name) { \
1511 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT, \
1512 "%s does not implement " #op_name, \
1513 lang->name); \
1514 } \
1515 return lang->op_##op_name(res, lhs, rhs); \
1516 }
1517 BINARY_OP(add)
1518 BINARY_OP(sub)
1519 BINARY_OP(mul)
1520 BINARY_OP(div)
1521 BINARY_OP(mod)
1522 BINARY_OP(lshift)
1523 BINARY_OP(rshift)
1524 BINARY_OP(and)
1525 BINARY_OP(or)
1526 BINARY_OP(xor)
1527 #undef BINARY_OP
1528
1529 #define UNARY_OP(op_name) \
1530 LIBDRGN_PUBLIC struct drgn_error * \
1531 drgn_object_##op_name(struct drgn_object *res, const struct drgn_object *obj) \
1532 { \
1533 const struct drgn_language *lang = drgn_object_language(obj); \
1534 \
1535 if (drgn_object_program(res) != drgn_object_program(obj)) { \
1536 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT, \
1537 "objects are from different programs");\
1538 } \
1539 if (!lang->op_##op_name) { \
1540 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT, \
1541 "%s does not implement " #op_name, \
1542 lang->name); \
1543 } \
1544 return lang->op_##op_name(res, obj); \
1545 }
1546 UNARY_OP(pos)
1547 UNARY_OP(neg)
1548 UNARY_OP(not)
1549 #undef UNARY_OP
1550
1551 LIBDRGN_PUBLIC struct drgn_error *
1552 drgn_object_address_of(struct drgn_object *res, const struct drgn_object *obj)
1553 {
1554 if (drgn_object_program(res) != drgn_object_program(obj)) {
1555 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1556 "objects are from different programs");
1557 }
1558
1559 SWITCH_ENUM(obj->kind) {
1560 case DRGN_OBJECT_VALUE:
1561 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
1562 "cannot take address of value");
1563 case DRGN_OBJECT_REFERENCE:
1564 break;
1565 case DRGN_OBJECT_ABSENT:
1566 return &drgn_error_object_absent;
1567 default:
1568 UNREACHABLE();
1569 }
1570
1571 if (obj->is_bit_field || obj->bit_offset) {
1572 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
1573 "cannot take address of bit field");
1574 }
1575
1576 struct drgn_qualified_type qualified_type =
1577 drgn_object_qualified_type(obj);
1578 uint64_t address_size;
1579 struct drgn_error *err =
1580 drgn_program_address_size(drgn_object_program(obj),
1581 &address_size);
1582 if (err)
1583 return err;
1584 struct drgn_qualified_type result_type;
1585 err = drgn_pointer_type_create(drgn_object_program(obj), qualified_type,
1586 address_size, DRGN_PROGRAM_ENDIAN,
1587 drgn_type_language(qualified_type.type),
1588 &result_type.type);
1589 if (err)
1590 return err;
1591 result_type.qualifiers = 0;
1592 return drgn_object_set_unsigned(res, result_type,
1593 obj->address, 0);
1594 }
1595
1596 LIBDRGN_PUBLIC struct drgn_error *
1597 drgn_object_subscript(struct drgn_object *res, const struct drgn_object *obj,
1598 int64_t index)
1599 {
1600 struct drgn_error *err;
1601 struct drgn_element_info element;
1602
1603 if (drgn_object_program(res) != drgn_object_program(obj)) {
1604 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1605 "objects are from different programs");
1606 }
1607
1608 err = drgn_program_element_info(drgn_object_program(obj), obj->type,
1609 &element);
1610 if (err)
1611 return err;
1612
1613 if (obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED) {
1614 return drgn_object_dereference_offset(res, obj,
1615 element.qualified_type,
1616 index * element.bit_size,
1617 0);
1618 } else {
1619 return drgn_object_fragment(res, obj, element.qualified_type,
1620 index * element.bit_size, 0);
1621 }
1622 }
1623
1624 LIBDRGN_PUBLIC
1625 struct drgn_error *drgn_object_slice(struct drgn_object *res,
1626 const struct drgn_object *obj,
1627 int64_t start, int64_t end)
1628 {
1629 struct drgn_error *err;
1630 struct drgn_program *prog = drgn_object_program(obj);
1631
1632 if (drgn_object_program(res) != prog) {
1633 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1634 "objects are from different programs");
1635 }
1636
1637 struct drgn_element_info element;
1638 err = drgn_program_element_info(drgn_object_program(obj), obj->type,
1639 &element);
1640 if (err)
1641 return err;
1642
1643 struct drgn_qualified_type array_type;
1644 err = drgn_array_type_create(prog, element.qualified_type,
1645 end > start ? end - start : 0,
1646 drgn_type_language(element.qualified_type.type),
1647 &array_type.type);
1648 if (err)
1649 return err;
1650 array_type.qualifiers = 0;
1651
1652 if (obj->encoding == DRGN_OBJECT_ENCODING_UNSIGNED) {
1653 return drgn_object_dereference_offset(res, obj, array_type,
1654 start * element.bit_size,
1655 0);
1656 } else {
1657 return drgn_object_fragment(res, obj, array_type,
1658 start * element.bit_size, 0);
1659 }
1660 }
1661
1662 LIBDRGN_PUBLIC struct drgn_error *
1663 drgn_object_member(struct drgn_object *res, const struct drgn_object *obj,
1664 const char *member_name)
1665 {
1666 struct drgn_error *err;
1667
1668 if (drgn_object_program(res) != drgn_object_program(obj)) {
1669 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1670 "objects are from different programs");
1671 }
1672
1673 struct drgn_type_member *member;
1674 uint64_t member_bit_offset;
1675 err = drgn_type_find_member(obj->type, member_name, &member,
1676 &member_bit_offset);
1677 if (err)
1678 return err;
1679 struct drgn_qualified_type member_type;
1680 uint64_t member_bit_field_size;
1681 err = drgn_member_type(member, &member_type, &member_bit_field_size);
1682 if (err)
1683 return err;
1684 return drgn_object_fragment(res, obj, member_type, member_bit_offset,
1685 member_bit_field_size);
1686 }
1687
1688 LIBDRGN_PUBLIC struct drgn_error *
1689 drgn_object_member_dereference(struct drgn_object *res,
1690 const struct drgn_object *obj,
1691 const char *member_name)
1692 {
1693 struct drgn_error *err;
1694
1695 if (drgn_object_program(res) != drgn_object_program(obj)) {
1696 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1697 "objects are from different programs");
1698 }
1699
1700 struct drgn_type *underlying_type = drgn_underlying_type(obj->type);
1701 if (drgn_type_kind(underlying_type) != DRGN_TYPE_POINTER) {
1702 return drgn_type_error("'%s' is not a pointer to a structure, union, or class",
1703 obj->type);
1704 }
1705
1706 struct drgn_type_member *member;
1707 uint64_t member_bit_offset;
1708 err = drgn_type_find_member(drgn_type_type(underlying_type).type,
1709 member_name, &member, &member_bit_offset);
1710 if (err)
1711 return err;
1712 struct drgn_qualified_type member_type;
1713 uint64_t member_bit_field_size;
1714 err = drgn_member_type(member, &member_type, &member_bit_field_size);
1715 if (err)
1716 return err;
1717 return drgn_object_dereference_offset(res, obj, member_type,
1718 member_bit_offset,
1719 member_bit_field_size);
1720 }
1721
1722 LIBDRGN_PUBLIC
1723 struct drgn_error *drgn_object_subobject(struct drgn_object *res,
1724 const struct drgn_object *obj,
1725 const char *designator)
1726 {
1727 struct drgn_error *err;
1728 const struct drgn_language *lang = drgn_object_language(obj);
1729 struct drgn_qualified_type qualified_type;
1730 uint64_t bit_offset, bit_field_size;
1731 err = lang->type_subobject(obj->type, designator, false,
1732 &qualified_type, &bit_offset,
1733 &bit_field_size);
1734 if (err)
1735 return err;
1736 return drgn_object_fragment(res, obj, qualified_type, bit_offset,
1737 bit_field_size);
1738 }
1739
1740 LIBDRGN_PUBLIC struct drgn_error *
1741 drgn_object_container_of(struct drgn_object *res, const struct drgn_object *obj,
1742 struct drgn_qualified_type qualified_type,
1743 const char *member_designator)
1744 {
1745 struct drgn_error *err;
1746
1747 if (drgn_object_program(res) != drgn_object_program(obj)) {
1748 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
1749 "objects are from different programs");
1750 }
1751
1752 if (drgn_type_kind(drgn_underlying_type(obj->type)) !=
1753 DRGN_TYPE_POINTER) {
1754 return drgn_type_error("container_of() argument must be a pointer, not '%s'",
1755 obj->type);
1756 }
1757
1758 uint64_t offset;
1759 err = drgn_type_offsetof(qualified_type.type, member_designator,
1760 &offset);
1761 if (err)
1762 return err;
1763
1764 uint64_t address;
1765 err = drgn_object_value_unsigned(obj, &address);
1766 if (err)
1767 return err;
1768
1769 uint64_t address_size;
1770 err = drgn_program_address_size(drgn_object_program(obj),
1771 &address_size);
1772 if (err)
1773 return err;
1774 struct drgn_qualified_type result_type;
1775 err = drgn_pointer_type_create(drgn_object_program(obj), qualified_type,
1776 address_size, DRGN_PROGRAM_ENDIAN,
1777 drgn_type_language(qualified_type.type),
1778 &result_type.type);
1779 if (err)
1780 return err;
1781 result_type.qualifiers = 0;
1782 return drgn_object_set_unsigned(res, result_type, address - offset, 0);
1783 }
1784
1785 LIBDRGN_PUBLIC struct drgn_error *
1786 drgn_object_sizeof(const struct drgn_object *obj, uint64_t *ret)
1787 {
1788 if (obj->is_bit_field) {
1789 return drgn_error_create(DRGN_ERROR_TYPE,
1790 "cannot get size of bit field");
1791 }
1792 return drgn_type_sizeof(obj->type, ret);
1793 }
1794
1795 static inline struct drgn_error *
1796 binary_operands_signed(const struct drgn_object *lhs,
1797 const struct drgn_object *rhs, uint64_t bit_size,
1798 int64_t *lhs_ret, int64_t *rhs_ret)
1799 {
1800 struct drgn_error *err;
1801
1802 err = drgn_object_convert_signed(lhs, bit_size, lhs_ret);
1803 if (err)
1804 return err;
1805 return drgn_object_convert_signed(rhs, bit_size, rhs_ret);
1806 }
1807
1808 static inline struct drgn_error *
1809 binary_operands_unsigned(const struct drgn_object *lhs,
1810 const struct drgn_object *rhs, uint64_t bit_size,
1811 uint64_t *lhs_ret, uint64_t *rhs_ret)
1812 {
1813 struct drgn_error *err;
1814
1815 err = drgn_object_convert_unsigned(lhs, bit_size, lhs_ret);
1816 if (err)
1817 return err;
1818 return drgn_object_convert_unsigned(rhs, bit_size, rhs_ret);
1819 }
1820
1821 static inline struct drgn_error *
1822 binary_operands_float(const struct drgn_object *lhs,
1823 const struct drgn_object *rhs, double *lhs_ret,
1824 double *rhs_ret)
1825 {
1826 struct drgn_error *err;
1827
1828 err = drgn_object_convert_float(lhs, lhs_ret);
1829 if (err)
1830 return err;
1831 return drgn_object_convert_float(rhs, rhs_ret);
1832 }
1833
1834 static struct drgn_error *pointer_operand(const struct drgn_object *ptr,
1835 uint64_t *ret)
1836 {
1837 switch (ptr->encoding) {
1838 case DRGN_OBJECT_ENCODING_UNSIGNED:
1839 return drgn_object_value_unsigned(ptr, ret);
1840 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
1841 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG:
1842 return &drgn_integer_too_big;
1843 case DRGN_OBJECT_ENCODING_BUFFER:
1844 case DRGN_OBJECT_ENCODING_NONE:
1845 case DRGN_OBJECT_ENCODING_INCOMPLETE_BUFFER:
1846 SWITCH_ENUM(ptr->kind) {
1847 case DRGN_OBJECT_VALUE:
1848 return drgn_error_format(DRGN_ERROR_INVALID_ARGUMENT,
1849 "cannot get address of value");
1850 case DRGN_OBJECT_REFERENCE:
1851 *ret = ptr->address;
1852 return NULL;
1853 case DRGN_OBJECT_ABSENT:
1854 return &drgn_error_object_absent;
1855 default:
1856 UNREACHABLE();
1857 }
1858 default:
1859 return drgn_error_create(DRGN_ERROR_TYPE,
1860 "invalid operand type for pointer arithmetic");
1861 }
1862 }
1863
1864 struct drgn_error *drgn_op_cast(struct drgn_object *res,
1865 const struct drgn_object_type *type,
1866 const struct drgn_object *obj,
1867 const struct drgn_operand_type *obj_type)
1868 {
1869 struct drgn_error *err;
1870
1871 bool is_pointer = (drgn_type_kind(obj_type->underlying_type) ==
1872 DRGN_TYPE_POINTER);
1873 switch (type->encoding) {
1874 case DRGN_OBJECT_ENCODING_BUFFER:
1875 return drgn_qualified_type_error("cannot cast to '%s'",
1876 drgn_object_type_qualified(type));
1877 case DRGN_OBJECT_ENCODING_SIGNED: {
1878 union {
1879 int64_t svalue;
1880 uint64_t uvalue;
1881 } tmp;
1882 if (is_pointer) {
1883 err = pointer_operand(obj, &tmp.uvalue);
1884 } else {
1885 err = drgn_object_convert_signed(obj, type->bit_size,
1886 &tmp.svalue);
1887 }
1888 if (err)
1889 goto err;
1890 return drgn_object_set_signed_internal(res, type, tmp.svalue);
1891 }
1892 case DRGN_OBJECT_ENCODING_UNSIGNED: {
1893 uint64_t uvalue;
1894 if (is_pointer) {
1895 err = pointer_operand(obj, &uvalue);
1896 } else {
1897 err = drgn_object_convert_unsigned(obj, type->bit_size,
1898 &uvalue);
1899 }
1900 if (err)
1901 goto err;
1902 return drgn_object_set_unsigned_internal(res, type, uvalue);
1903 }
1904 case DRGN_OBJECT_ENCODING_FLOAT: {
1905 if (is_pointer)
1906 goto type_error;
1907
1908 double fvalue;
1909 err = drgn_object_convert_float(obj, &fvalue);
1910 if (err)
1911 goto err;
1912 return drgn_object_set_float_internal(res, type, fvalue);
1913 }
1914 default:
1915 if (!drgn_object_encoding_is_complete(type->encoding)) {
1916 return drgn_error_incomplete_type("cannot cast to %s type",
1917 type->type);
1918 }
1919 goto type_error;
1920 }
1921
1922 err:
1923 if (err->code == DRGN_ERROR_TYPE) {
1924 drgn_error_destroy(err);
1925 goto type_error;
1926 }
1927 return err;
1928
1929 type_error:
1930 return drgn_2_qualified_types_error("cannot convert '%s' to '%s'",
1931 drgn_operand_type_qualified(obj_type),
1932 drgn_object_type_qualified(type));
1933 }
1934
1935 /*
1936 * Two's complement operator. Avoid undefined/implementation-defined behavior
1937 * (due to overflow or signed integer representation) for an arithmetic or
1938 * bitwise operator by doing the operation on unsigned operands and then
1939 * converting back to a signed integer.
1940 */
1941 #define BINARY_OP_SIGNED_2C(res, type, lhs, op, rhs) ({ \
1942 struct drgn_error *_err; \
1943 const struct drgn_object_type *_type = (type); \
1944 union { \
1945 int64_t svalue; \
1946 uint64_t uvalue; \
1947 } lhs_tmp, rhs_tmp, tmp; \
1948 _err = binary_operands_signed((lhs), (rhs), _type->bit_size, \
1949 &lhs_tmp.svalue, &rhs_tmp.svalue); \
1950 if (!_err) { \
1951 tmp.uvalue = lhs_tmp.uvalue op rhs_tmp.uvalue; \
1952 _err = drgn_object_set_signed_internal((res), _type, \
1953 tmp.svalue); \
1954 } \
1955 _err; \
1956 })
1957
1958 #define BINARY_OP_UNSIGNED(res, type, lhs, op, rhs) ({ \
1959 struct drgn_error *_err; \
1960 const struct drgn_object_type *_type = (type); \
1961 uint64_t lhs_uvalue, rhs_uvalue; \
1962 \
1963 _err = binary_operands_unsigned((lhs), (rhs), _type->bit_size, \
1964 &lhs_uvalue, &rhs_uvalue); \
1965 if (!_err) { \
1966 _err = drgn_object_set_unsigned_internal((res), _type, \
1967 lhs_uvalue op rhs_uvalue);\
1968 } \
1969 _err; \
1970 })
1971
1972 #define BINARY_OP_FLOAT(res, type, lhs, op, rhs) ({ \
1973 struct drgn_error *_err; \
1974 double lhs_fvalue, rhs_fvalue; \
1975 _err = binary_operands_float((lhs), (rhs), &lhs_fvalue, &rhs_fvalue); \
1976 if (!_err) { \
1977 _err = drgn_object_set_float_internal((res), (type), \
1978 lhs_fvalue op rhs_fvalue);\
1979 } \
1980 _err; \
1981 })
1982
1983 #define CMP(lhs, rhs) ({ \
1984 __auto_type _lhs = (lhs); \
1985 __auto_type _rhs = (rhs); \
1986 \
1987 (_lhs > _rhs ? 1 : _lhs < _rhs ? -1 : 0); \
1988 })
1989
1990 struct drgn_error *drgn_op_cmp_impl(const struct drgn_object *lhs,
1991 const struct drgn_object *rhs,
1992 const struct drgn_operand_type *op_type,
1993 int *ret)
1994 {
1995 struct drgn_error *err;
1996
1997 struct drgn_object_type type;
1998 err = drgn_object_type_operand(op_type, &type);
1999 if (err)
2000 return err;
2001
2002 switch (type.encoding) {
2003 case DRGN_OBJECT_ENCODING_SIGNED: {
2004 int64_t lhs_svalue, rhs_svalue;
2005 err = binary_operands_signed(lhs, rhs, type.bit_size,
2006 &lhs_svalue, &rhs_svalue);
2007 if (err)
2008 return err;
2009 *ret = CMP(lhs_svalue, rhs_svalue);
2010 return NULL;
2011 }
2012 case DRGN_OBJECT_ENCODING_UNSIGNED: {
2013 uint64_t lhs_uvalue, rhs_uvalue;
2014 err = binary_operands_unsigned(lhs, rhs, type.bit_size,
2015 &lhs_uvalue, &rhs_uvalue);
2016 if (err)
2017 return err;
2018 *ret = CMP(lhs_uvalue, rhs_uvalue);
2019 return NULL;
2020 }
2021 case DRGN_OBJECT_ENCODING_FLOAT: {
2022 double lhs_fvalue, rhs_fvalue;
2023 err = binary_operands_float(lhs, rhs, &lhs_fvalue, &rhs_fvalue);
2024 if (err)
2025 return err;
2026 *ret = CMP(lhs_fvalue, rhs_fvalue);
2027 return NULL;
2028 }
2029 default:
2030 return drgn_error_create(DRGN_ERROR_TYPE,
2031 "invalid operand type for cmp");
2032 }
2033 }
2034
2035 struct drgn_error *drgn_op_cmp_pointers(const struct drgn_object *lhs,
2036 const struct drgn_object *rhs, int *ret)
2037 {
2038 struct drgn_error *err;
2039 uint64_t lhs_value, rhs_value;
2040
2041 err = pointer_operand(lhs, &lhs_value);
2042 if (err)
2043 return err;
2044 err = pointer_operand(rhs, &rhs_value);
2045 if (err)
2046 return err;
2047
2048 *ret = CMP(lhs_value, rhs_value);
2049 return NULL;
2050 }
2051
2052 #undef CMP
2053
2054 #define ARITHMETIC_BINARY_OP(op_name, op) \
2055 struct drgn_error * \
2056 drgn_op_##op_name##_impl(struct drgn_object *res, \
2057 const struct drgn_operand_type *op_type, \
2058 const struct drgn_object *lhs, \
2059 const struct drgn_object *rhs) \
2060 { \
2061 struct drgn_error *err; \
2062 struct drgn_object_type type; \
2063 err = drgn_object_type_operand(op_type, &type); \
2064 if (err) \
2065 return err; \
2066 switch (type.encoding) { \
2067 case DRGN_OBJECT_ENCODING_SIGNED: \
2068 return BINARY_OP_SIGNED_2C(res, &type, lhs, op, rhs); \
2069 case DRGN_OBJECT_ENCODING_UNSIGNED: \
2070 return BINARY_OP_UNSIGNED(res, &type, lhs, op, rhs); \
2071 case DRGN_OBJECT_ENCODING_FLOAT: \
2072 return BINARY_OP_FLOAT(res, &type, lhs, op, rhs); \
2073 default: \
2074 return drgn_error_create(DRGN_ERROR_TYPE, \
2075 "invalid result type for " #op_name); \
2076 } \
2077 }
2078 ARITHMETIC_BINARY_OP(add, +)
2079 ARITHMETIC_BINARY_OP(sub, -)
2080 #undef ARITHMETIC_BINARY_OP
2081
2082 struct drgn_error *
2083 drgn_op_add_to_pointer(struct drgn_object *res,
2084 const struct drgn_operand_type *op_type,
2085 uint64_t referenced_size, bool negate,
2086 const struct drgn_object *ptr,
2087 const struct drgn_object *index)
2088 {
2089 struct drgn_error *err;
2090
2091 struct drgn_object_type type;
2092 err = drgn_object_type_operand(op_type, &type);
2093 if (err)
2094 return err;
2095 if (type.encoding != DRGN_OBJECT_ENCODING_UNSIGNED) {
2096 return drgn_error_create(DRGN_ERROR_TYPE,
2097 "invalid result type for pointer arithmetic");
2098 }
2099
2100 uint64_t ptr_value;
2101 err = pointer_operand(ptr, &ptr_value);
2102 if (err)
2103 return err;
2104
2105 uint64_t index_value;
2106 switch (index->encoding) {
2107 case DRGN_OBJECT_ENCODING_SIGNED: {
2108 int64_t svalue;
2109 err = drgn_object_value_signed(index, &svalue);
2110 if (err)
2111 return err;
2112 if (svalue >= 0) {
2113 index_value = svalue;
2114 } else {
2115 index_value = -svalue;
2116 negate = !negate;
2117 }
2118 break;
2119 }
2120 case DRGN_OBJECT_ENCODING_UNSIGNED:
2121 err = drgn_object_value_unsigned(index, &index_value);
2122 if (err)
2123 return err;
2124 break;
2125 case DRGN_OBJECT_ENCODING_SIGNED_BIG:
2126 case DRGN_OBJECT_ENCODING_UNSIGNED_BIG:
2127 return &drgn_integer_too_big;
2128 default:
2129 return drgn_error_create(DRGN_ERROR_TYPE,
2130 "invalid addend type for pointer arithmetic");
2131 }
2132
2133 if (negate)
2134 ptr_value -= index_value * referenced_size;
2135 else
2136 ptr_value += index_value * referenced_size;
2137 return drgn_object_set_unsigned_internal(res, &type, ptr_value);
2138 }
2139
2140 struct drgn_error *drgn_op_sub_pointers(struct drgn_object *res,
2141 const struct drgn_operand_type *op_type,
2142 uint64_t referenced_size,
2143 const struct drgn_object *lhs,
2144 const struct drgn_object *rhs)
2145 {
2146 struct drgn_error *err;
2147
2148 if (!referenced_size) {
2149 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
2150 "object size must not be zero");
2151 }
2152
2153 struct drgn_object_type type;
2154 err = drgn_object_type_operand(op_type, &type);
2155 if (err)
2156 return err;
2157 if (type.encoding != DRGN_OBJECT_ENCODING_SIGNED) {
2158 return drgn_error_create(DRGN_ERROR_TYPE,
2159 "invalid result type for pointer subtraction");
2160 }
2161
2162 uint64_t lhs_value, rhs_value;
2163 err = pointer_operand(lhs, &lhs_value);
2164 if (err)
2165 return err;
2166 err = pointer_operand(rhs, &rhs_value);
2167 if (err)
2168 return err;
2169
2170 int64_t diff;
2171 if (lhs_value >= rhs_value)
2172 diff = (lhs_value - rhs_value) / referenced_size;
2173 else
2174 diff = -((rhs_value - lhs_value) / referenced_size);
2175 return drgn_object_set_signed_internal(res, &type, diff);
2176 }
2177
2178 struct drgn_error *drgn_op_mul_impl(struct drgn_object *res,
2179 const struct drgn_operand_type *op_type,
2180 const struct drgn_object *lhs,
2181 const struct drgn_object *rhs)
2182 {
2183 struct drgn_error *err;
2184
2185 struct drgn_object_type type;
2186 err = drgn_object_type_operand(op_type, &type);
2187 if (err)
2188 return err;
2189
2190 switch (type.encoding) {
2191 case DRGN_OBJECT_ENCODING_SIGNED: {
2192 int64_t lhs_svalue, rhs_svalue;
2193 err = binary_operands_signed(lhs, rhs, type.bit_size,
2194 &lhs_svalue, &rhs_svalue);
2195 if (err)
2196 return err;
2197
2198 /*
2199 * Convert to sign and magnitude to avoid signed integer
2200 * overflow.
2201 */
2202 bool lhs_negative = lhs_svalue < 0;
2203 uint64_t lhs_uvalue = lhs_negative ? -lhs_svalue : lhs_svalue;
2204 bool rhs_negative = rhs_svalue < 0;
2205 uint64_t rhs_uvalue = rhs_negative ? -rhs_svalue : rhs_svalue;
2206 union {
2207 int64_t svalue;
2208 uint64_t uvalue;
2209 } tmp;
2210 tmp.uvalue = lhs_uvalue * rhs_uvalue;
2211 if (lhs_negative != rhs_negative)
2212 tmp.uvalue = -tmp.uvalue;
2213 return drgn_object_set_signed_internal(res, &type, tmp.svalue);
2214 }
2215 case DRGN_OBJECT_ENCODING_UNSIGNED:
2216 return BINARY_OP_UNSIGNED(res, &type, lhs, *, rhs);
2217 case DRGN_OBJECT_ENCODING_FLOAT:
2218 return BINARY_OP_FLOAT(res, &type, lhs, *, rhs);
2219 default:
2220 return drgn_error_create(DRGN_ERROR_TYPE,
2221 "invalid result type for mul");
2222 }
2223 }
2224
2225 static struct drgn_error drgn_zero_division = {
2226 .code = DRGN_ERROR_ZERO_DIVISION,
2227 .message = "division by zero",
2228 };
2229
2230 struct drgn_error *drgn_op_div_impl(struct drgn_object *res,
2231 const struct drgn_operand_type *op_type,
2232 const struct drgn_object *lhs,
2233 const struct drgn_object *rhs)
2234 {
2235 struct drgn_error *err;
2236
2237 struct drgn_object_type type;
2238 err = drgn_object_type_operand(op_type, &type);
2239 if (err)
2240 return err;
2241
2242 switch (type.encoding) {
2243 case DRGN_OBJECT_ENCODING_SIGNED: {
2244 int64_t lhs_svalue, rhs_svalue;
2245 err = binary_operands_signed(lhs, rhs, type.bit_size,
2246 &lhs_svalue, &rhs_svalue);
2247 if (err)
2248 return err;
2249 if (!rhs_svalue)
2250 return &drgn_zero_division;
2251 return drgn_object_set_signed_internal(res, &type,
2252 lhs_svalue / rhs_svalue);
2253 }
2254 case DRGN_OBJECT_ENCODING_UNSIGNED: {
2255 uint64_t lhs_uvalue, rhs_uvalue;
2256 err = binary_operands_unsigned(lhs, rhs, type.bit_size,
2257 &lhs_uvalue, &rhs_uvalue);
2258 if (err)
2259 return err;
2260 if (!rhs_uvalue)
2261 return &drgn_zero_division;
2262 return drgn_object_set_unsigned_internal(res, &type,
2263 lhs_uvalue / rhs_uvalue);
2264 }
2265 case DRGN_OBJECT_ENCODING_FLOAT: {
2266 double lhs_fvalue, rhs_fvalue;
2267 err = binary_operands_float(lhs, rhs, &lhs_fvalue, &rhs_fvalue);
2268 if (err)
2269 return err;
2270 if (!rhs_fvalue)
2271 return &drgn_zero_division;
2272 return drgn_object_set_float_internal(res, &type,
2273 lhs_fvalue / rhs_fvalue);
2274 }
2275 default:
2276 return drgn_error_create(DRGN_ERROR_TYPE,
2277 "invalid result type for div");
2278 }
2279 }
2280
2281 struct drgn_error *drgn_op_mod_impl(struct drgn_object *res,
2282 const struct drgn_operand_type *op_type,
2283 const struct drgn_object *lhs,
2284 const struct drgn_object *rhs)
2285 {
2286 struct drgn_error *err;
2287
2288 struct drgn_object_type type;
2289 err = drgn_object_type_operand(op_type, &type);
2290 if (err)
2291 return err;
2292
2293 switch (type.encoding) {
2294 case DRGN_OBJECT_ENCODING_SIGNED: {
2295 int64_t lhs_svalue, rhs_svalue;
2296 err = binary_operands_signed(lhs, rhs, type.bit_size,
2297 &lhs_svalue, &rhs_svalue);
2298 if (err)
2299 return err;
2300 if (!rhs_svalue)
2301 return &drgn_zero_division;
2302 return drgn_object_set_signed_internal(res, &type,
2303 lhs_svalue % rhs_svalue);
2304 }
2305 case DRGN_OBJECT_ENCODING_UNSIGNED: {
2306 uint64_t lhs_uvalue, rhs_uvalue;
2307 err = binary_operands_unsigned(lhs, rhs, type.bit_size,
2308 &lhs_uvalue, &rhs_uvalue);
2309 if (err)
2310 return err;
2311 if (!rhs_uvalue)
2312 return &drgn_zero_division;
2313 return drgn_object_set_unsigned_internal(res, &type,
2314 lhs_uvalue % rhs_uvalue);
2315 }
2316 default:
2317 return drgn_error_create(DRGN_ERROR_TYPE,
2318 "invalid result type for mod");
2319 }
2320 }
2321
2322 static struct drgn_error *shift_operand(const struct drgn_object *rhs,
2323 const struct drgn_operand_type *rhs_type,
2324 uint64_t *ret)
2325 {
2326 struct drgn_error *err;
2327
2328 struct drgn_object_type type;
2329 err = drgn_object_type_operand(rhs_type, &type);
2330 if (err)
2331 return err;
2332
2333 switch (type.encoding) {
2334 case DRGN_OBJECT_ENCODING_SIGNED: {
2335 int64_t rhs_svalue;
2336 err = drgn_object_convert_signed(rhs, type.bit_size,
2337 &rhs_svalue);
2338 if (err)
2339 return err;
2340 if (rhs_svalue < 0) {
2341 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
2342 "negative shift count");
2343 }
2344 *ret = rhs_svalue;
2345 return NULL;
2346 }
2347 case DRGN_OBJECT_ENCODING_UNSIGNED:
2348 return drgn_object_convert_unsigned(rhs, type.bit_size, ret);
2349 default:
2350 return drgn_error_create(DRGN_ERROR_TYPE,
2351 "invalid rhs type for shift");
2352 }
2353 }
2354
2355 struct drgn_error *drgn_op_lshift_impl(struct drgn_object *res,
2356 const struct drgn_object *lhs,
2357 const struct drgn_operand_type *lhs_type,
2358 const struct drgn_object *rhs,
2359 const struct drgn_operand_type *rhs_type)
2360 {
2361 struct drgn_error *err;
2362
2363 struct drgn_object_type type;
2364 err = drgn_object_type_operand(lhs_type, &type);
2365 if (err)
2366 return err;
2367
2368 uint64_t shift;
2369 err = shift_operand(rhs, rhs_type, &shift);
2370 if (err)
2371 return err;
2372
2373 switch (type.encoding) {
2374 case DRGN_OBJECT_ENCODING_SIGNED: {
2375 union {
2376 int64_t svalue;
2377 uint64_t uvalue;
2378 } tmp;
2379 err = drgn_object_convert_signed(lhs, type.bit_size,
2380 &tmp.svalue);
2381 if (err)
2382 return err;
2383 /* Left shift of a negative integer is undefined. */
2384 if (shift < type.bit_size)
2385 tmp.uvalue <<= shift;
2386 else
2387 tmp.uvalue = 0;
2388 return drgn_object_set_signed_internal(res, &type, tmp.svalue);
2389 }
2390 case DRGN_OBJECT_ENCODING_UNSIGNED: {
2391 uint64_t uvalue;
2392 err = drgn_object_convert_unsigned(lhs, type.bit_size,
2393 &uvalue);
2394 if (err)
2395 return err;
2396 if (shift < type.bit_size)
2397 uvalue <<= shift;
2398 else
2399 uvalue = 0;
2400 return drgn_object_set_unsigned_internal(res, &type, uvalue);
2401 }
2402 default:
2403 return drgn_error_create(DRGN_ERROR_TYPE,
2404 "invalid result type for lshift");
2405 }
2406 }
2407
2408 struct drgn_error *drgn_op_rshift_impl(struct drgn_object *res,
2409 const struct drgn_object *lhs,
2410 const struct drgn_operand_type *lhs_type,
2411 const struct drgn_object *rhs,
2412 const struct drgn_operand_type *rhs_type)
2413 {
2414 struct drgn_error *err;
2415
2416 struct drgn_object_type type;
2417 err = drgn_object_type_operand(lhs_type, &type);
2418 if (err)
2419 return err;
2420
2421 uint64_t shift;
2422 err = shift_operand(rhs, rhs_type, &shift);
2423 if (err)
2424 return err;
2425
2426 switch (type.encoding) {
2427 case DRGN_OBJECT_ENCODING_SIGNED: {
2428 int64_t svalue;
2429 err = drgn_object_convert_signed(lhs, type.bit_size, &svalue);
2430 if (err)
2431 return err;
2432 if (shift < type.bit_size)
2433 svalue >>= shift;
2434 else if (svalue >= 0)
2435 svalue = 0;
2436 else
2437 svalue = -1;
2438 return drgn_object_set_signed_internal(res, &type, svalue);
2439 }
2440 case DRGN_OBJECT_ENCODING_UNSIGNED: {
2441 uint64_t uvalue;
2442 err = drgn_object_convert_unsigned(lhs, type.bit_size, &uvalue);
2443 if (err)
2444 return err;
2445 if (shift < type.bit_size)
2446 uvalue >>= shift;
2447 else
2448 uvalue = 0;
2449 return drgn_object_set_unsigned_internal(res, &type, uvalue);
2450 }
2451 default:
2452 return drgn_error_create(DRGN_ERROR_TYPE,
2453 "invalid result type for lshift");
2454 }
2455 }
2456
2457 #define INTEGER_BINARY_OP(op_name, op) \
2458 struct drgn_error * \
2459 drgn_op_##op_name##_impl(struct drgn_object *res, \
2460 const struct drgn_operand_type *op_type, \
2461 const struct drgn_object *lhs, \
2462 const struct drgn_object *rhs) \
2463 { \
2464 struct drgn_error *err; \
2465 struct drgn_object_type type; \
2466 err = drgn_object_type_operand(op_type, &type); \
2467 if (err) \
2468 return err; \
2469 switch (type.encoding) { \
2470 case DRGN_OBJECT_ENCODING_SIGNED: \
2471 return BINARY_OP_SIGNED_2C(res, &type, lhs, op, rhs); \
2472 case DRGN_OBJECT_ENCODING_UNSIGNED: \
2473 return BINARY_OP_UNSIGNED(res, &type, lhs, op, rhs); \
2474 default: \
2475 return drgn_error_create(DRGN_ERROR_TYPE, \
2476 "invalid result type for " #op_name); \
2477 } \
2478 }
2479 INTEGER_BINARY_OP(and, &)
2480 INTEGER_BINARY_OP(or, |)
2481 INTEGER_BINARY_OP(xor, ^)
2482 #undef INTEGER_BINARY_OP
2483
2484 /* See BINARY_OP_SIGNED_2C. */
2485 #define UNARY_OP_SIGNED_2C(res, type, op, obj) ({ \
2486 struct drgn_error *_err; \
2487 const struct drgn_object_type *_type = (type); \
2488 union { \
2489 int64_t svalue; \
2490 uint64_t uvalue; \
2491 } tmp; \
2492 _err = drgn_object_convert_signed((obj), _type->bit_size, &tmp.svalue); \
2493 tmp.uvalue = op tmp.uvalue; \
2494 if (!_err) { \
2495 _err = drgn_object_set_signed_internal((res), _type, \
2496 tmp.svalue); \
2497 } \
2498 _err; \
2499 })
2500
2501 #define UNARY_OP_UNSIGNED(res, type, op, obj) ({ \
2502 struct drgn_error *_err; \
2503 const struct drgn_object_type *_type = (type); \
2504 uint64_t uvalue; \
2505 _err = drgn_object_convert_unsigned((obj), _type->bit_size, &uvalue); \
2506 if (!_err) { \
2507 _err = drgn_object_set_unsigned_internal((res), _type, \
2508 op uvalue); \
2509 } \
2510 _err; \
2511 })
2512
2513 #define ARITHMETIC_UNARY_OP(op_name, op) \
2514 struct drgn_error * \
2515 drgn_op_##op_name##_impl(struct drgn_object *res, \
2516 const struct drgn_operand_type *op_type, \
2517 const struct drgn_object *obj) \
2518 { \
2519 struct drgn_error *err; \
2520 struct drgn_object_type type; \
2521 err = drgn_object_type_operand(op_type, &type); \
2522 if (err) \
2523 return err; \
2524 switch (type.encoding) { \
2525 case DRGN_OBJECT_ENCODING_SIGNED: \
2526 return UNARY_OP_SIGNED_2C(res, &type, op, obj); \
2527 case DRGN_OBJECT_ENCODING_UNSIGNED: \
2528 return UNARY_OP_UNSIGNED(res, &type, op, obj); \
2529 case DRGN_OBJECT_ENCODING_FLOAT: { \
2530 double fvalue; \
2531 err = drgn_object_convert_float(obj, &fvalue); \
2532 if (err) \
2533 return err; \
2534 return drgn_object_set_float_internal(res, &type, op fvalue); \
2535 \
2536 } \
2537 default: \
2538 return drgn_error_create(DRGN_ERROR_TYPE, \
2539 "invalid result type for " #op_name); \
2540 } \
2541 }
2542 ARITHMETIC_UNARY_OP(pos, +)
2543 ARITHMETIC_UNARY_OP(neg, -)
2544 #undef ARITHMETIC_UNARY_OP
2545
2546 struct drgn_error *drgn_op_not_impl(struct drgn_object *res,
2547 const struct drgn_operand_type *op_type,
2548 const struct drgn_object *obj)
2549 {
2550 struct drgn_error *err;
2551 struct drgn_object_type type;
2552 err = drgn_object_type_operand(op_type, &type);
2553 if (err)
2554 return err;
2555 switch (type.encoding) {
2556 case DRGN_OBJECT_ENCODING_SIGNED:
2557 return UNARY_OP_SIGNED_2C(res, &type, ~, obj);
2558 case DRGN_OBJECT_ENCODING_UNSIGNED:
2559 return UNARY_OP_UNSIGNED(res, &type, ~, obj);
2560 default:
2561 return drgn_error_create(DRGN_ERROR_TYPE,
2562 "invalid result type for not");
2563 }
2564 }