-
Notifications
You must be signed in to change notification settings - Fork 55
/
Copy pathctf-types.c
1694 lines (1361 loc) · 43.8 KB
/
ctf-types.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Type handling functions.
Copyright (C) 2019-2025 Free Software Foundation, Inc.
This file is part of libctf.
libctf is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; see the file COPYING. If not see
<http://www.gnu.org/licenses/>. */
#include <ctf-impl.h>
#include <assert.h>
#include <string.h>
/* Determine whether a type is a parent or a child. */
int
ctf_type_isparent (ctf_dict_t *fp, ctf_id_t id)
{
return (LCTF_TYPE_ISPARENT (fp, id));
}
int
ctf_type_ischild (ctf_dict_t * fp, ctf_id_t id)
{
return (LCTF_TYPE_ISCHILD (fp, id));
}
/* Expand a structure element into the passed-in ctf_lmember_t. */
static int
ctf_struct_member (ctf_dict_t *fp, ctf_lmember_t *dst, const ctf_type_t *tp,
unsigned char *vlen, size_t vbytes, size_t n)
{
if (!ctf_assert (fp, n < LCTF_INFO_VLEN (fp, tp->ctt_info)))
return -1; /* errno is set for us. */
/* Already large. */
if (tp->ctt_size == CTF_LSIZE_SENT)
{
ctf_lmember_t *lmp = (ctf_lmember_t *) vlen;
if (!ctf_assert (fp, (n + 1) * sizeof (ctf_lmember_t) <= vbytes))
return -1; /* errno is set for us. */
memcpy (dst, &lmp[n], sizeof (ctf_lmember_t));
}
else
{
ctf_member_t *mp = (ctf_member_t *) vlen;
dst->ctlm_name = mp[n].ctm_name;
dst->ctlm_type = mp[n].ctm_type;
dst->ctlm_offsetlo = mp[n].ctm_offset;
dst->ctlm_offsethi = 0;
}
return 0;
}
/* Iterate over the members of a STRUCT or UNION. We pass the name, member
type, and offset of each member to the specified callback function. */
int
ctf_member_iter (ctf_dict_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
{
ctf_next_t *i = NULL;
ssize_t offset;
const char *name;
ctf_id_t membtype;
while ((offset = ctf_member_next (fp, type, &i, &name, &membtype, 0)) >= 0)
{
int rc;
if ((rc = func (name, membtype, offset, arg)) != 0)
{
ctf_next_destroy (i);
return rc;
}
}
if (ctf_errno (fp) != ECTF_NEXT_END)
return -1; /* errno is set for us. */
return 0;
}
/* Iterate over the members of a STRUCT or UNION, returning each member's
offset and optionally name and member type in turn. On end-of-iteration,
returns -1. If FLAGS is CTF_MN_RECURSE, recurse into unnamed members. */
ssize_t
ctf_member_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
const char **name, ctf_id_t *membtype, int flags)
{
ctf_dict_t *ofp = fp;
uint32_t kind;
ssize_t offset;
uint32_t max_vlen;
ctf_next_t *i = *it;
if (!i)
{
const ctf_type_t *tp;
ctf_dtdef_t *dtd;
ssize_t size;
ssize_t increment;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
return -1; /* errno is set for us. */
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return -1; /* errno is set for us. */
if ((i = ctf_next_create ()) == NULL)
return ctf_set_errno (ofp, ENOMEM);
i->cu.ctn_fp = ofp;
i->ctn_tp = tp;
ctf_get_ctt_size (fp, tp, &size, &increment);
kind = LCTF_INFO_KIND (fp, tp->ctt_info);
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
{
ctf_next_destroy (i);
return (ctf_set_errno (ofp, ECTF_NOTSOU));
}
if ((dtd = ctf_dynamic_type (fp, type)) != NULL)
{
i->u.ctn_vlen = dtd->dtd_vlen;
i->ctn_size = dtd->dtd_vlen_alloc;
}
else
{
unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
i->u.ctn_vlen = (unsigned char *) tp + increment;
i->ctn_size = LCTF_VBYTES (fp, kind, size, vlen);;
}
i->ctn_iter_fun = (void (*) (void)) ctf_member_next;
i->ctn_n = 0;
*it = i;
}
if ((void (*) (void)) ctf_member_next != i->ctn_iter_fun)
return (ctf_set_errno (ofp, ECTF_NEXT_WRONGFUN));
if (ofp != i->cu.ctn_fp)
return (ctf_set_errno (ofp, ECTF_NEXT_WRONGFP));
/* Resolve to the native dict of this type. */
if ((fp = ctf_get_dict (ofp, type)) == NULL)
return (ctf_set_errno (ofp, ECTF_NOPARENT));
max_vlen = LCTF_INFO_VLEN (fp, i->ctn_tp->ctt_info);
/* When we hit an unnamed struct/union member, we set ctn_type to indicate
that we are inside one, then return the unnamed member: on the next call,
we must skip over top-level member iteration in favour of iteration within
the sub-struct until it later turns out that that iteration has ended. */
retry:
if (!i->ctn_type)
{
ctf_lmember_t memb;
const char *membname;
if (i->ctn_n == max_vlen)
goto end_iter;
if (ctf_struct_member (fp, &memb, i->ctn_tp, i->u.ctn_vlen, i->ctn_size,
i->ctn_n) < 0)
return (ctf_set_errno (ofp, ctf_errno (fp)));
membname = ctf_strptr (fp, memb.ctlm_name);
if (name)
*name = membname;
if (membtype)
*membtype = memb.ctlm_type;
offset = (unsigned long) CTF_LMEM_OFFSET (&memb);
if (membname[0] == 0
&& (ctf_type_kind (fp, memb.ctlm_type) == CTF_K_STRUCT
|| ctf_type_kind (fp, memb.ctlm_type) == CTF_K_UNION))
i->ctn_type = memb.ctlm_type;
i->ctn_n++;
/* The callers might want automatic recursive sub-struct traversal. */
if (!(flags & CTF_MN_RECURSE))
i->ctn_type = 0;
/* Sub-struct traversal starting? Take note of the offset of this member,
for later boosting of sub-struct members' offsets. */
if (i->ctn_type)
i->ctn_increment = offset;
}
/* Traversing a sub-struct? Just return it, with the offset adjusted. */
else
{
ssize_t ret = ctf_member_next (fp, i->ctn_type, &i->ctn_next, name,
membtype, flags);
if (ret >= 0)
return ret + i->ctn_increment;
if (ctf_errno (fp) != ECTF_NEXT_END)
{
ctf_next_destroy (i);
*it = NULL;
i->ctn_type = 0;
ctf_set_errno (ofp, ctf_errno (fp));
return ret;
}
if (!ctf_assert (fp, (i->ctn_next == NULL)))
return (ctf_set_errno (ofp, ctf_errno (fp)));
i->ctn_type = 0;
/* This sub-struct has ended: on to the next real member. */
goto retry;
}
return offset;
end_iter:
ctf_next_destroy (i);
*it = NULL;
return ctf_set_errno (ofp, ECTF_NEXT_END);
}
/* Iterate over the members of an ENUM. We pass the string name and associated
integer value of each enum element to the specified callback function. */
int
ctf_enum_iter (ctf_dict_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
{
ctf_next_t *i = NULL;
const char *name;
int val;
while ((name = ctf_enum_next (fp, type, &i, &val)) != NULL)
{
int rc;
if ((rc = func (name, val, arg)) != 0)
{
ctf_next_destroy (i);
return rc;
}
}
if (ctf_errno (fp) != ECTF_NEXT_END)
return -1; /* errno is set for us. */
return 0;
}
/* Iterate over the members of an enum TYPE, returning each enumerand's NAME or
NULL at end of iteration or error, and optionally passing back the
enumerand's integer VALue. */
const char *
ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
int *val)
{
ctf_dict_t *ofp = fp;
uint32_t kind;
const char *name;
ctf_next_t *i = *it;
if (!i)
{
const ctf_type_t *tp;
ctf_dtdef_t *dtd;
if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
return NULL; /* errno is set for us. */
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return NULL; /* errno is set for us. */
if ((i = ctf_next_create ()) == NULL)
{
ctf_set_errno (ofp, ENOMEM);
return NULL;
}
i->cu.ctn_fp = ofp;
(void) ctf_get_ctt_size (fp, tp, NULL,
&i->ctn_increment);
kind = LCTF_INFO_KIND (fp, tp->ctt_info);
if (kind != CTF_K_ENUM)
{
ctf_next_destroy (i);
ctf_set_errno (ofp, ECTF_NOTENUM);
return NULL;
}
dtd = ctf_dynamic_type (fp, type);
i->ctn_iter_fun = (void (*) (void)) ctf_enum_next;
i->ctn_n = LCTF_INFO_VLEN (fp, tp->ctt_info);
if (dtd == NULL)
i->u.ctn_en = (const ctf_enum_t *) ((uintptr_t) tp +
i->ctn_increment);
else
i->u.ctn_en = (const ctf_enum_t *) dtd->dtd_vlen;
*it = i;
}
if ((void (*) (void)) ctf_enum_next != i->ctn_iter_fun)
{
ctf_set_errno (ofp, ECTF_NEXT_WRONGFUN);
return NULL;
}
if (ofp != i->cu.ctn_fp)
{
ctf_set_errno (ofp, ECTF_NEXT_WRONGFP);
return NULL;
}
/* Resolve to the native dict of this type. */
if ((fp = ctf_get_dict (ofp, type)) == NULL)
{
ctf_set_errno (ofp, ECTF_NOPARENT);
return NULL;
}
if (i->ctn_n == 0)
goto end_iter;
name = ctf_strptr (fp, i->u.ctn_en->cte_name);
if (val)
*val = i->u.ctn_en->cte_value;
i->u.ctn_en++;
i->ctn_n--;
return name;
end_iter:
ctf_next_destroy (i);
*it = NULL;
ctf_set_errno (ofp, ECTF_NEXT_END);
return NULL;
}
/* Iterate over every root (user-visible) type in the given CTF dict.
We pass the type ID of each type to the specified callback function.
Does not traverse parent types: you have to do that explicitly. This is by
design, to avoid traversing them more than once if traversing many children
of a single parent. */
int
ctf_type_iter (ctf_dict_t *fp, ctf_type_f *func, void *arg)
{
ctf_next_t *i = NULL;
ctf_id_t type;
while ((type = ctf_type_next (fp, &i, NULL, 0)) != CTF_ERR)
{
int rc;
if ((rc = func (type, arg)) != 0)
{
ctf_next_destroy (i);
return rc;
}
}
if (ctf_errno (fp) != ECTF_NEXT_END)
return -1; /* errno is set for us. */
return 0;
}
/* Iterate over every type in the given CTF dict, user-visible or not.
We pass the type ID of each type to the specified callback function.
Does not traverse parent types: you have to do that explicitly. This is by
design, to avoid traversing them more than once if traversing many children
of a single parent. */
int
ctf_type_iter_all (ctf_dict_t *fp, ctf_type_all_f *func, void *arg)
{
ctf_next_t *i = NULL;
ctf_id_t type;
int flag;
while ((type = ctf_type_next (fp, &i, &flag, 1)) != CTF_ERR)
{
int rc;
if ((rc = func (type, flag, arg)) != 0)
{
ctf_next_destroy (i);
return rc;
}
}
if (ctf_errno (fp) != ECTF_NEXT_END)
return -1; /* errno is set for us. */
return 0;
}
/* Iterate over every type in the given CTF dict, optionally including
non-user-visible types, returning each type ID and hidden flag in turn.
Returns CTF_ERR on end of iteration or error.
Does not traverse parent types: you have to do that explicitly. This is by
design, to avoid traversing them more than once if traversing many children
of a single parent. */
ctf_id_t
ctf_type_next (ctf_dict_t *fp, ctf_next_t **it, int *flag, int want_hidden)
{
ctf_next_t *i = *it;
if (!i)
{
if ((i = ctf_next_create ()) == NULL)
return ctf_set_typed_errno (fp, ENOMEM);
i->cu.ctn_fp = fp;
i->ctn_type = 1;
i->ctn_iter_fun = (void (*) (void)) ctf_type_next;
*it = i;
}
if ((void (*) (void)) ctf_type_next != i->ctn_iter_fun)
return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFUN));
if (fp != i->cu.ctn_fp)
return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFP));
while (i->ctn_type <= fp->ctf_typemax)
{
const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR (fp, i->ctn_type);
if ((!want_hidden) && (!LCTF_INFO_ISROOT (fp, tp->ctt_info)))
{
i->ctn_type++;
continue;
}
if (flag)
*flag = LCTF_INFO_ISROOT (fp, tp->ctt_info);
return LCTF_INDEX_TO_TYPE (fp, i->ctn_type++, fp->ctf_flags & LCTF_CHILD);
}
ctf_next_destroy (i);
*it = NULL;
return ctf_set_typed_errno (fp, ECTF_NEXT_END);
}
/* Iterate over every variable in the given CTF dict, in arbitrary order.
We pass the name of each variable to the specified callback function. */
int
ctf_variable_iter (ctf_dict_t *fp, ctf_variable_f *func, void *arg)
{
ctf_next_t *i = NULL;
ctf_id_t type;
const char *name;
while ((type = ctf_variable_next (fp, &i, &name)) != CTF_ERR)
{
int rc;
if ((rc = func (name, type, arg)) != 0)
{
ctf_next_destroy (i);
return rc;
}
}
if (ctf_errno (fp) != ECTF_NEXT_END)
return -1; /* errno is set for us. */
return 0;
}
/* Iterate over every variable in the given CTF dict, in arbitrary order,
returning the name and type of each variable in turn. The name argument is
not optional. Returns CTF_ERR on end of iteration or error. */
ctf_id_t
ctf_variable_next (ctf_dict_t *fp, ctf_next_t **it, const char **name)
{
ctf_next_t *i = *it;
ctf_id_t id;
if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
return (ctf_set_typed_errno (fp, ECTF_NOPARENT));
if (!i)
{
if ((i = ctf_next_create ()) == NULL)
return ctf_set_typed_errno (fp, ENOMEM);
i->cu.ctn_fp = fp;
i->ctn_iter_fun = (void (*) (void)) ctf_variable_next;
i->u.ctn_dvd = ctf_list_next (&fp->ctf_dvdefs);
*it = i;
}
if ((void (*) (void)) ctf_variable_next != i->ctn_iter_fun)
return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFUN));
if (fp != i->cu.ctn_fp)
return (ctf_set_typed_errno (fp, ECTF_NEXT_WRONGFP));
if (i->ctn_n < fp->ctf_nvars)
{
*name = ctf_strptr (fp, fp->ctf_vars[i->ctn_n].ctv_name);
return fp->ctf_vars[i->ctn_n++].ctv_type;
}
if (i->u.ctn_dvd == NULL)
goto end_iter;
*name = i->u.ctn_dvd->dvd_name;
id = i->u.ctn_dvd->dvd_type;
i->u.ctn_dvd = ctf_list_next (i->u.ctn_dvd);
return id;
end_iter:
ctf_next_destroy (i);
*it = NULL;
return ctf_set_typed_errno (fp, ECTF_NEXT_END);
}
/* Follow a given type through the graph for TYPEDEF, VOLATILE, CONST, and
RESTRICT nodes until we reach a "base" type node. This is useful when
we want to follow a type ID to a node that has members or a size. To guard
against infinite loops, we implement simplified cycle detection and check
each link against itself, the previous node, and the topmost node.
Does not drill down through slices to their contained type.
Callers of this function must not presume that a type it returns must have a
valid ctt_size: forwards do not, and must be separately handled. */
ctf_id_t
ctf_type_resolve (ctf_dict_t *fp, ctf_id_t type)
{
ctf_id_t prev = type, otype = type;
ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
if (type == 0)
return (ctf_set_typed_errno (ofp, ECTF_NONREPRESENTABLE));
while ((tp = ctf_lookup_by_id (&fp, type)) != NULL)
{
switch (LCTF_INFO_KIND (fp, tp->ctt_info))
{
case CTF_K_TYPEDEF:
case CTF_K_VOLATILE:
case CTF_K_CONST:
case CTF_K_RESTRICT:
if (tp->ctt_type == type || tp->ctt_type == otype
|| tp->ctt_type == prev)
{
ctf_err_warn (ofp, 0, ECTF_CORRUPT, _("type %lx cycle detected"),
otype);
return (ctf_set_typed_errno (ofp, ECTF_CORRUPT));
}
prev = type;
type = tp->ctt_type;
break;
case CTF_K_UNKNOWN:
return (ctf_set_typed_errno (ofp, ECTF_NONREPRESENTABLE));
default:
return type;
}
if (type == 0)
return (ctf_set_typed_errno (ofp, ECTF_NONREPRESENTABLE));
}
return CTF_ERR; /* errno is set for us. */
}
/* Like ctf_type_resolve(), but traverse down through slices to their contained
type. */
ctf_id_t
ctf_type_resolve_unsliced (ctf_dict_t *fp, ctf_id_t type)
{
ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
return CTF_ERR;
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return CTF_ERR; /* errno is set for us. */
if ((LCTF_INFO_KIND (fp, tp->ctt_info)) == CTF_K_SLICE)
{
ctf_id_t ret;
if ((ret = ctf_type_reference (fp, type)) == CTF_ERR)
return (ctf_set_typed_errno (ofp, ctf_errno (fp)));
return ret;
}
return type;
}
/* Return the native dict of a given type: if called on a child and the
type is in the parent, return the parent. Needed if you plan to access
the type directly, without using the API. */
ctf_dict_t *
ctf_get_dict (ctf_dict_t *fp, ctf_id_t type)
{
if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, type))
return fp->ctf_parent;
return fp;
}
/* Look up a name in the given name table, in the appropriate hash given the
kind of the identifier. The name is a raw, undecorated identifier. */
ctf_id_t ctf_lookup_by_rawname (ctf_dict_t *fp, int kind, const char *name)
{
return (ctf_id_t) (uintptr_t)
ctf_dynhash_lookup (ctf_name_table (fp, kind), name);
}
/* Lookup the given type ID and return its name as a new dynamically-allocated
string. */
char *
ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
{
ctf_decl_t cd;
ctf_decl_node_t *cdp;
ctf_decl_prec_t prec, lp, rp;
int ptr, arr;
uint32_t k;
char *buf;
if (fp == NULL && type == CTF_ERR)
return NULL; /* Simplify caller code by permitting CTF_ERR. */
ctf_decl_init (&cd);
ctf_decl_push (&cd, fp, type);
if (cd.cd_err != 0)
{
ctf_decl_fini (&cd);
ctf_set_errno (fp, cd.cd_err);
return NULL;
}
/* If the type graph's order conflicts with lexical precedence order
for pointers or arrays, then we need to surround the declarations at
the corresponding lexical precedence with parentheses. This can
result in either a parenthesized pointer (*) as in int (*)() or
int (*)[], or in a parenthesized pointer and array as in int (*[])(). */
ptr = cd.cd_order[CTF_PREC_POINTER] > CTF_PREC_POINTER;
arr = cd.cd_order[CTF_PREC_ARRAY] > CTF_PREC_ARRAY;
rp = arr ? CTF_PREC_ARRAY : ptr ? CTF_PREC_POINTER : -1;
lp = ptr ? CTF_PREC_POINTER : arr ? CTF_PREC_ARRAY : -1;
k = CTF_K_POINTER; /* Avoid leading whitespace (see below). */
for (prec = CTF_PREC_BASE; prec < CTF_PREC_MAX; prec++)
{
for (cdp = ctf_list_next (&cd.cd_nodes[prec]);
cdp != NULL; cdp = ctf_list_next (cdp))
{
ctf_dict_t *rfp = fp;
const ctf_type_t *tp = ctf_lookup_by_id (&rfp, cdp->cd_type);
const char *name = ctf_strptr (rfp, tp->ctt_name);
if (k != CTF_K_POINTER && k != CTF_K_ARRAY)
ctf_decl_sprintf (&cd, " ");
if (lp == prec)
{
ctf_decl_sprintf (&cd, "(");
lp = -1;
}
switch (cdp->cd_kind)
{
case CTF_K_INTEGER:
case CTF_K_FLOAT:
case CTF_K_TYPEDEF:
/* Integers, floats, and typedefs must always be named types. */
if (name[0] == '\0')
{
ctf_set_errno (fp, ECTF_CORRUPT);
ctf_decl_fini (&cd);
return NULL;
}
ctf_decl_sprintf (&cd, "%s", name);
break;
case CTF_K_POINTER:
ctf_decl_sprintf (&cd, "*");
break;
case CTF_K_ARRAY:
ctf_decl_sprintf (&cd, "[%u]", cdp->cd_n);
break;
case CTF_K_FUNCTION:
{
size_t i;
ctf_funcinfo_t fi;
ctf_id_t *argv = NULL;
if (ctf_func_type_info (rfp, cdp->cd_type, &fi) < 0)
goto err; /* errno is set for us. */
if ((argv = calloc (fi.ctc_argc, sizeof (ctf_id_t *))) == NULL)
{
ctf_set_errno (rfp, errno);
goto err;
}
if (ctf_func_type_args (rfp, cdp->cd_type,
fi.ctc_argc, argv) < 0)
goto err; /* errno is set for us. */
ctf_decl_sprintf (&cd, "(*) (");
for (i = 0; i < fi.ctc_argc; i++)
{
char *arg = ctf_type_aname (rfp, argv[i]);
if (arg == NULL)
goto err; /* errno is set for us. */
ctf_decl_sprintf (&cd, "%s", arg);
free (arg);
if ((i < fi.ctc_argc - 1)
|| (fi.ctc_flags & CTF_FUNC_VARARG))
ctf_decl_sprintf (&cd, ", ");
}
if (fi.ctc_flags & CTF_FUNC_VARARG)
ctf_decl_sprintf (&cd, "...");
ctf_decl_sprintf (&cd, ")");
free (argv);
break;
err:
ctf_set_errno (fp, ctf_errno (rfp));
free (argv);
ctf_decl_fini (&cd);
return NULL;
}
break;
case CTF_K_STRUCT:
ctf_decl_sprintf (&cd, "struct %s", name);
break;
case CTF_K_UNION:
ctf_decl_sprintf (&cd, "union %s", name);
break;
case CTF_K_ENUM:
ctf_decl_sprintf (&cd, "enum %s", name);
break;
case CTF_K_FORWARD:
{
switch (ctf_type_kind_forwarded (fp, cdp->cd_type))
{
case CTF_K_STRUCT:
ctf_decl_sprintf (&cd, "struct %s", name);
break;
case CTF_K_UNION:
ctf_decl_sprintf (&cd, "union %s", name);
break;
case CTF_K_ENUM:
ctf_decl_sprintf (&cd, "enum %s", name);
break;
default:
ctf_set_errno (fp, ECTF_CORRUPT);
ctf_decl_fini (&cd);
return NULL;
}
break;
}
case CTF_K_VOLATILE:
ctf_decl_sprintf (&cd, "volatile");
break;
case CTF_K_CONST:
ctf_decl_sprintf (&cd, "const");
break;
case CTF_K_RESTRICT:
ctf_decl_sprintf (&cd, "restrict");
break;
case CTF_K_UNKNOWN:
if (name[0] == '\0')
ctf_decl_sprintf (&cd, _("(nonrepresentable type)"));
else
ctf_decl_sprintf (&cd, _("(nonrepresentable type %s)"),
name);
break;
}
k = cdp->cd_kind;
}
if (rp == prec)
ctf_decl_sprintf (&cd, ")");
}
if (cd.cd_enomem)
(void) ctf_set_errno (fp, ENOMEM);
buf = ctf_decl_buf (&cd);
ctf_decl_fini (&cd);
return buf;
}
/* Lookup the given type ID and print a string name for it into buf. Return
the actual number of bytes (not including \0) needed to format the name. */
ssize_t
ctf_type_lname (ctf_dict_t *fp, ctf_id_t type, char *buf, size_t len)
{
char *str = ctf_type_aname (fp, type);
size_t slen;
if (str == NULL)
return -1; /* errno is set for us. */
slen = strlen (str);
snprintf (buf, len, "%s", str);
free (str);
if (slen >= len)
(void) ctf_set_errno (fp, ECTF_NAMELEN);
return slen;
}
/* Lookup the given type ID and print a string name for it into buf. If buf
is too small, return NULL: the ECTF_NAMELEN error is set on 'fp' for us. */
char *
ctf_type_name (ctf_dict_t *fp, ctf_id_t type, char *buf, size_t len)
{
ssize_t rv = ctf_type_lname (fp, type, buf, len);
return (rv >= 0 && (size_t) rv < len ? buf : NULL);
}
/* Lookup the given type ID and return its raw, unadorned, undecorated name.
The name will live as long as its ctf_dict_t does.
The only decoration is that a NULL return always means an error: nameless
types return a null string. */
const char *
ctf_type_name_raw (ctf_dict_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return NULL; /* errno is set for us. */
if (tp->ctt_name == 0)
return "";
return ctf_strraw (fp, tp->ctt_name);
}
/* Lookup the given type ID and return its raw, unadorned, undecorated name as a
new dynamically-allocated string. */
char *
ctf_type_aname_raw (ctf_dict_t *fp, ctf_id_t type)
{
const char *name = ctf_type_name_raw (fp, type);
if (name != NULL)
return strdup (name);
return NULL;
}
/* Resolve the type down to a base type node, and then return the size
of the type storage in bytes. */
ssize_t
ctf_type_size (ctf_dict_t *fp, ctf_id_t type)
{
ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
ssize_t size;
ctf_arinfo_t ar;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
return -1; /* errno is set for us. */
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return -1; /* errno is set for us. */
switch (LCTF_INFO_KIND (fp, tp->ctt_info))
{
case CTF_K_POINTER:
return fp->ctf_dmodel->ctd_pointer;
case CTF_K_FUNCTION:
return 0; /* Function size is only known by symtab. */
case CTF_K_ENUM:
return fp->ctf_dmodel->ctd_int;
case CTF_K_ARRAY:
/* ctf_add_array() does not directly encode the element size, but
requires the user to multiply to determine the element size.
If ctf_get_ctt_size() returns nonzero, then use the recorded
size instead. */
if ((size = ctf_get_ctt_size (fp, tp, NULL, NULL)) > 0)
return size;
if (ctf_array_info (ofp, type, &ar) < 0
|| (size = ctf_type_size (ofp, ar.ctr_contents)) < 0)
return -1; /* errno is set for us. */
return size * ar.ctr_nelems;
case CTF_K_FORWARD:
/* Forwards do not have a meaningful size. */
return (ctf_set_errno (ofp, ECTF_INCOMPLETE));
default: /* including slices of enums, etc */
return (ctf_get_ctt_size (fp, tp, NULL, NULL));
}
}
/* Resolve the type down to a base type node, and then return the alignment
needed for the type storage in bytes.
XXX may need arch-dependent attention. */
ssize_t
ctf_type_align (ctf_dict_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
ctf_dict_t *ofp = fp;
int kind;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
return -1; /* errno is set for us. */
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return -1; /* errno is set for us. */
kind = LCTF_INFO_KIND (fp, tp->ctt_info);
switch (kind)
{
case CTF_K_POINTER:
case CTF_K_FUNCTION:
return fp->ctf_dmodel->ctd_pointer;
case CTF_K_ARRAY:
{
ctf_arinfo_t r;
if (ctf_array_info (ofp, type, &r) < 0)
return -1; /* errno is set for us. */
return (ctf_type_align (ofp, r.ctr_contents));
}
case CTF_K_STRUCT:
case CTF_K_UNION:
{
size_t align = 0;
ctf_dtdef_t *dtd;
unsigned char *vlen;
uint32_t i = 0, n = LCTF_INFO_VLEN (fp, tp->ctt_info);
ssize_t size, increment, vbytes;
ctf_get_ctt_size (fp, tp, &size, &increment);
if ((dtd = ctf_dynamic_type (fp, type)) != NULL)
{
vlen = dtd->dtd_vlen;
vbytes = dtd->dtd_vlen_alloc;
}
else
{
vlen = (unsigned char *) tp + increment;
vbytes = LCTF_VBYTES (fp, kind, size, n);
}