12259 CTF shouldn't assume enum size

          --- old/usr/src/test/util-tests/tests/ctf/check-common.h
          +++ new/usr/src/test/util-tests/tests/ctf/check-common.h

   1    1  /*
   2    2   * This file and its contents are supplied under the terms of the

   3    3   * Common Development and Distribution License ("CDDL"), version 1.0.
   4    4   * You may only use this file in accordance with the terms of version
   5    5   * 1.0 of the CDDL.
   6    6   *
   7    7   * A full copy of the text of the CDDL should have accompanied this
   8    8   * source.  A copy of the CDDL is also available via the Internet at
   9    9   * http://www.illumos.org/license/CDDL.
  10   10   */
  11   11  
  12   12  /*
  13      - * Copyright 2019, Joyent, Inc.
       13 + * Copyright 2020 Joyent, Inc.
  14   14   */
  15   15  
  16   16  #ifndef _CHECK_COMMON_H
  17   17  #define _CHECK_COMMON_H
  18   18  
  19   19  /*
  20   20   * Common definitions for the CTF tests
  21   21   */
  22   22  
  23   23  #include <stdlib.h>

  24   24  #include <unistd.h>
  25   25  #include <libctf.h>
  26   26  #include <err.h>
  27   27  #include <strings.h>
  28   28  #include <sys/param.h>
  29   29  
  30   30  #ifdef __cplusplus
  31   31  extern "C" {
  32   32  #endif
  33   33  
  34   34  typedef struct check_number {
  35   35          const char *cn_tname;
  36   36          uint_t cn_kind;
  37   37          uint_t cn_flags;
  38   38          uint_t cn_offset;
  39   39          uint_t cn_size;
  40   40  } check_number_t;
  41   41  
  42   42  typedef struct check_symbol {
  43   43          const char *cs_symbol;
  44   44          const char *cs_type;
  45   45  } check_symbol_t;
  46   46  
  47   47  typedef struct check_descent {
  48   48          const char *cd_tname;
  49   49          uint_t cd_kind;
  50   50          const char *cd_contents;
  51   51          uint_t cd_nents;
  52   52  } check_descent_t;
  53   53  
  54   54  typedef struct check_descent_test {
  55   55          const char *cdt_sym;
  56   56          const check_descent_t *cdt_tests;
  57   57  } check_descent_test_t;
  58   58  
  59   59  typedef struct check_enum {
  60   60          const char *ce_name;
  61   61          int64_t ce_value;
  62   62  } check_enum_t;
  63   63  
  64   64  typedef struct check_enum_test {
  65   65          const char *cet_type;
  66   66          const check_enum_t *cet_tests;
  67   67  } check_enum_test_t;
  68   68  
  69   69  typedef struct check_member {
  70   70          const char *cm_name;
  71   71          const char *cm_type;
  72   72          ulong_t cm_offset;
  73   73  } check_member_t;
  74   74  
  75   75  typedef struct check_member_test {
  76   76          const char *cmt_type;
  77   77          int cmt_kind;
  78   78          size_t cmt_size;
  79   79          const check_member_t *cmt_members;

  80   80  } check_member_test_t;
  81   81  
  82   82  typedef struct check_function_test {
  83   83          const char *cft_name;
  84   84          const char *cft_rtype;
  85   85          uint_t cft_nargs;
  86   86          uint_t cft_flags;
  87   87          const char **cft_args;
  88   88  } check_function_test_t;
  89   89  
       90 +typedef struct check_size_test {
       91 +        const char *cst_name;
       92 +        size_t cst_size;
       93 +} check_size_test_t;
       94 +
  90   95  /*
  91   96   * Looks up each type and verifies that it matches the expected type.
  92   97   */
  93   98  extern boolean_t ctftest_check_numbers(ctf_file_t *, const check_number_t *);
  94   99  
  95  100  /*
  96  101   * Looks at each symbol specified and verifies that it matches the expected
  97  102   * type.
  98  103   */
  99  104  extern boolean_t ctftest_check_symbols(ctf_file_t *, const check_symbol_t *);

 100  105  
 101  106  /*
 102  107   * Given a symbol name which refers to a type, walks all the references of that
 103  108   * type and checks against it with each subsequent entry.
 104  109   */
 105  110  extern boolean_t ctftest_check_descent(const char *, ctf_file_t *,
 106  111      const check_descent_t *, boolean_t);
 107  112  
 108  113  /*
 109  114   * Checks that all of the listed members of an enum are present and have the
 110  115   * right values.
 111  116   */
 112  117  extern boolean_t ctftest_check_enum(const char *, ctf_file_t *,
 113  118      const check_enum_t *);
 114  119  
 115  120  /*
 116  121   * Checks that all of the members of a structure or union are present and have
 117  122   * the right types and byte offsets. This can be used for either structures or
 118  123   * unions.
 119  124   */
 120  125  extern boolean_t ctftest_check_members(const char *, ctf_file_t *, int, size_t,
 121  126      const check_member_t *);
 122  127  

 123  128  /*
 124  129   * Check that the named function or function pointer has the correct return
 125  130   * type, arguments, and function flags.
 126  131   */
 127  132  extern boolean_t ctftest_check_function(const char *, ctf_file_t *,
 128  133      const char *, uint_t, uint_t, const char **);
 129  134  extern boolean_t ctftest_check_fptr(const char *, ctf_file_t *,
 130  135      const char *, uint_t, uint_t, const char **);
 131  136  
 132  137  /*
      138 + * Check size of types.
      139 + */
      140 +extern boolean_t ctftest_check_size(const char *, ctf_file_t *, size_t);
      141 +
      142 +/*
 133  143   * Determine whether or not we have a duplicate type or not based on its name.
 134  144   */
 135  145  extern boolean_t ctftest_duplicates(ctf_file_t *);
 136  146  
 137  147  #ifdef __cplusplus
 138  148  }
 139  149  #endif
 140  150  
 141  151  #endif /* _CHECK_COMMON_H */
    

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX