objcommon.h

   1 #include <bfd.h>
   2 #include <limits.h>
   3 #include <stdarg.h>
   4 #include <stdbool.h>
   5 #include <stddef.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #define BITS_PER_LONG LONG_BIT
  11 #define _PASTE(x, y) x##y
  12 #define PASTE(x, y) _PASTE(x, y)
  13
  14 #define DIE do { fprintf(stderr, "ksplice: died at %s:%d\n", __FILE__, __LINE__); abort(); } while(0)
  15 #define assert(x) do { if(!(x)) DIE; } while(0)
  16 #define align(x, n) ((((x)+(n)-1)/(n))*(n))
  17
  18 #define container_of(ptr, type, member) ({                      \
  19         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
  20         (type *)( (char *)__mptr - offsetof(type,member) );})
  21
  22 #define DECLARE_VEC_TYPE(elt_t, vectype)        \
  23         struct vectype {                        \
  24                 elt_t *data;                    \
  25                 size_t size;                    \
  26                 size_t mem_size;                \
  27         }
  28
  29 /* void vec_init(struct vectype *vec); */
  30 #define vec_init(vec) *(vec) = (typeof(*(vec))) { NULL, 0, 0 }
  31
  32 /* void vec_move(struct vectype *dstvec, struct vectype *srcvec); */
  33 #define vec_move(dstvec, srcvec) do {                   \
  34                 typeof(srcvec) _srcvec = (srcvec);      \
  35                 *(dstvec) = *(_srcvec);                 \
  36                 vec_init(_srcvec);                      \
  37         } while (0)
  38
  39 /* void vec_free(struct vectype *vec); */
  40 #define vec_free(vec) do {                      \
  41                 typeof(vec) _vec1 = (vec);      \
  42                 free(_vec1->data);              \
  43                 vec_init(_vec1);                \
  44         } while (0)
  45
  46 void vec_do_reserve(void **data, size_t *mem_size, size_t newsize);
  47
  48 /* void vec_reserve(struct vectype *vec, size_t new_mem_size); */
  49 #define vec_reserve(vec, new_mem_size) do {                             \
  50                 typeof(vec) _vec2 = (vec);                              \
  51                 vec_do_reserve((void **)&_vec2->data, &_vec2->mem_size, \
  52                                (new_mem_size));                         \
  53         } while (0)
  54
  55 /* void vec_resize(struct vectype *vec, size_t new_size); */
  56 #define vec_resize(vec, new_size) do {                                  \
  57                 typeof(vec) _vec3 = (vec);                              \
  58                 _vec3->size = (new_size);                               \
  59                 vec_reserve(_vec3, _vec3->size * sizeof(*_vec3->data)); \
  60         } while (0)
  61
  62 /* elt_t *vec_grow(struct vectype *vec, size_t n); */
  63 #define vec_grow(vec, n) ({                             \
  64                 typeof(vec) _vec4 = (vec);              \
  65                 size_t _n = (n);                        \
  66                 vec_resize(_vec4, _vec4->size + _n);    \
  67                 _vec4->data + (_vec4->size - _n);       \
  68         })
  69
  70 DECLARE_VEC_TYPE(void, void_vec);
  71 DECLARE_VEC_TYPE(arelent *, arelentp_vec);
  72 DECLARE_VEC_TYPE(asymbol *, asymbolp_vec);
  73 DECLARE_VEC_TYPE(asymbol **, asymbolpp_vec);
  74
  75 #define DECLARE_HASH_TYPE(elt_t, hashtype,                              \
  76                           hashtype_init, hashtype_free,                 \
  77                           hashtype_lookup)                              \
  78         struct hashtype {                                               \
  79                 struct bfd_hash_table root;                             \
  80         };                                                              \
  81                                                                         \
  82         void hashtype_init(struct hashtype *table);                     \
  83         void hashtype_free(struct hashtype *table);                     \
  84         typeof(elt_t) *hashtype_lookup(struct hashtype *table,          \
  85                                        const char *string,              \
  86                                        bfd_boolean create)
  87
  88 #ifndef BFD_HASH_TABLE_HAS_ENTSIZE
  89 #define bfd_hash_table_init(table, newfunc, entry)      \
  90         bfd_hash_table_init(table, newfunc)
  91 #endif
  92
  93 #define IMPLEMENT_HASH_TYPE(elt_t, hashtype,                            \
  94                             hashtype_init, hashtype_free,               \
  95                             hashtype_lookup,                            \
  96                             elt_construct)                              \
  97                                                                         \
  98         struct hashtype##_entry {                                       \
  99                 struct bfd_hash_entry root;                             \
 100                 typeof(elt_t) val;                                      \
 101         };                                                              \
 102                                                                         \
 103         static struct bfd_hash_entry *hashtype##_newfunc(               \
 104             struct bfd_hash_entry *entry,                               \
 105             struct bfd_hash_table *table,                               \
 106             const char *string)                                         \
 107         {                                                               \
 108                 if (entry == NULL) {                                    \
 109                         entry = bfd_hash_allocate(table,                \
 110                             sizeof(struct hashtype##_entry));           \
 111                         if (entry == NULL)                              \
 112                                 return entry;                           \
 113                 }                                                       \
 114                 entry = bfd_hash_newfunc(entry, table, string);         \
 115                 typeof(elt_t) *v =                                      \
 116                     &container_of(entry, struct hashtype##_entry,       \
 117                                   root)->val;                           \
 118                 elt_construct(v);                                       \
 119                 return entry;                                           \
 120         };                                                              \
 121                                                                         \
 122         void hashtype_init(struct hashtype *table)                      \
 123         {                                                               \
 124                 bfd_hash_table_init(&table->root, hashtype##_newfunc,   \
 125                                     sizeof(struct hashtype##_entry));   \
 126         }                                                               \
 127                                                                         \
 128         void hashtype_free(struct hashtype *table)                      \
 129         {                                                               \
 130                 bfd_hash_table_free(&table->root);                      \
 131         }                                                               \
 132                                                                         \
 133         typeof(elt_t) *hashtype_lookup(struct hashtype *table,          \
 134                                        const char *string,              \
 135                                        bfd_boolean create)              \
 136         {                                                               \
 137                 struct bfd_hash_entry *e =                              \
 138                     bfd_hash_lookup(&table->root, string, create,       \
 139                                     TRUE);                              \
 140                 if (create)                                             \
 141                         assert(e != NULL);                              \
 142                 else if (e == NULL)                                     \
 143                         return NULL;                                    \
 144                 return &container_of(e, struct hashtype##_entry,        \
 145                                      root)->val;                        \
 146         }                                                               \
 147                                                                         \
 148         struct eat_trailing_semicolon
 149
 150 #define DEFINE_HASH_TYPE(elt_t, hashtype,                               \
 151                          hashtype_init, hashtype_free,                  \
 152                          hashtype_lookup,                               \
 153                          elt_construct)                                 \
 154         DECLARE_HASH_TYPE(elt_t, hashtype, hashtype_init,               \
 155                           hashtype_free, hashtype_lookup);              \
 156         IMPLEMENT_HASH_TYPE(elt_t, hashtype, hashtype_init,             \
 157                             hashtype_free, hashtype_lookup,             \
 158                             elt_construct);
 159
 160
 161 #ifndef bfd_get_section_size
 162 #define bfd_get_section_size(x) ((x)->_cooked_size)
 163 #endif
 164
 165 DECLARE_HASH_TYPE(arelent *, arelentp_hash, arelentp_hash_init,
 166                   arelentp_hash_free, arelentp_hash_lookup);
 167 DECLARE_HASH_TYPE(asymbol **, asymbolpp_hash, asymbolpp_hash_init,
 168                   asymbolpp_hash_free, asymbolpp_hash_lookup);
 169 DECLARE_HASH_TYPE(const char *, string_hash, string_hash_init,
 170                   string_hash_free, string_hash_lookup);
 171
 172 struct label_map {
 173         asymbol *csym;
 174         const char *orig_label;
 175         const char *label;
 176         int count;
 177 };
 178 DECLARE_VEC_TYPE(struct label_map, label_map_vec);
 179 DECLARE_HASH_TYPE(struct label_map *, label_mapp_hash, label_mapp_hash_init,
 180                   label_mapp_hash_free, label_mapp_hash_lookup);
 181
 182 struct entry_point {
 183         const char *label;
 184         const char *name;
 185         long offset;
 186         asymbol *symbol;
 187 };
 188 DECLARE_VEC_TYPE(struct entry_point, entry_point_vec);
 189
 190 struct span {
 191         struct supersect *ss;
 192         asymbol *symbol;
 193         const char *orig_label;
 194         const char *label;
 195         bfd_vma start;
 196         bfd_vma size;
 197         bfd_vma contents_size;
 198         bool keep;
 199         bool new;
 200         bool patch;
 201         bool bugpatch;
 202         bool datapatch;
 203         bool precallable;
 204         struct span *match;
 205         struct entry_point_vec entry_points;
 206         struct entry_point_vec pre_entry_points;
 207         bfd_size_type shift;
 208 };
 209 DECLARE_VEC_TYPE(struct span, span_vec);
 210
 211 struct superbfd {
 212         bfd *abfd;
 213         struct asymbolp_vec syms;
 214         struct supersect *new_supersects;
 215         struct label_map_vec maps;
 216         struct label_mapp_hash maps_hash;
 217         struct asymbolpp_vec new_syms;
 218         struct asymbolpp_hash csyms;
 219         struct string_hash callers;
 220 };
 221
 222 enum supersect_type {
 223         SS_TYPE_TEXT, SS_TYPE_DATA, SS_TYPE_RODATA, SS_TYPE_STRING,
 224         SS_TYPE_SPECIAL, SS_TYPE_IGNORED, SS_TYPE_KSPLICE, SS_TYPE_EXPORT,
 225         SS_TYPE_EXIT, SS_TYPE_KSPLICE_CALL, SS_TYPE_KSPLICE_EXTRACT,
 226         SS_TYPE_BUGTABLE, SS_TYPE_UNKNOWN
 227 };
 228
 229 struct supersect {
 230         struct superbfd *parent;
 231         const char *name;
 232         flagword flags;
 233         struct void_vec contents;
 234         int alignment;
 235         unsigned int entsize;
 236         struct arelentp_vec relocs;
 237         struct arelentp_vec new_relocs;
 238         struct supersect *next;
 239         struct asymbolp_vec syms;
 240         struct span_vec spans;
 241         struct arelentp_hash reloc_hash;
 242         asymbol *symbol;
 243         bool keep;
 244         enum supersect_type type;
 245         enum supersect_type orig_type;
 246 };
 247
 248 struct superbfd *fetch_superbfd(bfd *abfd);
 249 struct supersect *fetch_supersect(struct superbfd *sbfd, asection *sect);
 250 struct supersect *new_supersect(struct superbfd *sbfd, const char *name);
 251 void supersect_move(struct supersect *dest_ss, struct supersect *src_ss);
 252
 253 #define sect_grow(ss, n, type)                                  \
 254         ((type *)sect_do_grow(ss, n, sizeof(type), __alignof__(type)))
 255 void *sect_do_grow(struct supersect *ss, size_t n, size_t size, int alignment);
 256
 257 #define sect_copy(dest_ss, dest, src_ss, src, n)                        \
 258         sect_do_copy(dest_ss, dest, src_ss, src, (n) * sizeof(*(src)))
 259 void sect_do_copy(struct supersect *dest_ss, void *dest,
 260                   struct supersect *src_ss, const void *src, size_t n);
 261
 262 #define strstarts(str, prefix)                          \
 263         (strncmp(str, prefix, strlen(prefix)) == 0)
 264 #define ends_with(str, suffix)                                          \
 265         (strlen(str) >= strlen(suffix) &&                               \
 266          strcmp(&str[strlen(str) - strlen(suffix)], suffix) == 0)
 267
 268 bfd_vma addr_offset(struct supersect *ss, const void *addr);
 269 bfd_vma reloc_offset(struct supersect *ss, arelent *reloc);
 270 arelent *find_reloc(struct supersect *ss, const void *addr);
 271 bfd_vma read_reloc(struct supersect *ss, const void *addr, size_t size,
 272                    asymbol **symp);
 273 const void *read_pointer(struct supersect *ss, void *const *addr,
 274                          struct supersect **ssp);
 275 const char *read_string(struct supersect *ss, const char *const *addr);
 276
 277 #define read_num(ss, addr) ((typeof(*(addr))) \
 278                             read_reloc(ss, addr, sizeof(*(addr)), NULL))
 279
 280 static inline char *vstrprintf(const char *fmt, va_list ap)
 281 {
 282         char *str;
 283         assert(vasprintf(&str, fmt, ap) >= 0);
 284         return str;
 285 }
 286
 287 static inline char * __attribute__((format (printf, 1, 2)))
 288 strprintf(const char *fmt, ...)
 289 {
 290         va_list ap;
 291         va_start(ap, fmt);
 292         char *str = vstrprintf(fmt, ap);
 293         va_end(ap);
 294         return str;
 295 }