lib.h

   1 #ifndef LIB_H
   2 #define LIB_H
   3
   4 #include <stdlib.h>
   5 #include <stddef.h>
   6
   7 /*
   8  * Basic helper routine descriptions for 'sparse'.
   9  *
  10  * Copyright (C) 2003 Transmeta Corp.
  11  *               2003 Linus Torvalds
  12  *               2004 Christopher Li
  13  *
  14  *  Licensed under the Open Software License version 1.1
  15  */
  16
  17 #include "compat.h"
  18
  19 extern int verbose, optimize, preprocessing;
  20 extern int repeat_phase, merge_phi_sources;
  21
  22 #define container(ptr, type, member) \
  23         (type *)((void *)(ptr) - offsetof(type, member))
  24
  25 extern unsigned int hexval(unsigned int c);
  26
  27 struct position {
  28         unsigned int type:6,
  29                      stream:10,
  30                      newline:1,
  31                      whitespace:1,
  32                      pos:14;
  33         unsigned int line:31,
  34                      noexpand:1;
  35 };
  36
  37 struct ident;
  38 struct token;
  39 struct symbol;
  40 struct statement;
  41 struct expression;
  42 struct basic_block;
  43 struct entrypoint;
  44 struct instruction;
  45 struct multijmp;
  46 struct pseudo;
  47
  48 /* Silly type-safety check ;) */
  49 #define DECLARE_PTR_LIST(listname,type) struct listname { type *list[1]; }
  50 #define CHECK_TYPE(head,ptr)            (void)(&(ptr) == &(head)->list[0])
  51 #define TYPEOF(head)                    __typeof__(&(head)->list[0])
  52 #define VRFY_PTR_LIST(head)             (void)(sizeof((head)->list[0]))
  53
  54 DECLARE_PTR_LIST(symbol_list, struct symbol);
  55 DECLARE_PTR_LIST(statement_list, struct statement);
  56 DECLARE_PTR_LIST(expression_list, struct expression);
  57 DECLARE_PTR_LIST(basic_block_list, struct basic_block);
  58 DECLARE_PTR_LIST(instruction_list, struct instruction);
  59 DECLARE_PTR_LIST(multijmp_list, struct multijmp);
  60 DECLARE_PTR_LIST(pseudo_list, struct pseudo);
  61
  62 typedef struct pseudo *pseudo_t;
  63
  64 struct token *skip_to(struct token *, int);
  65 struct token *expect(struct token *, int, const char *);
  66 #ifdef __GNUC__
  67 #define FORMAT_ATTR(pos) __attribute__ ((__format__ (__printf__, pos, pos+1)))
  68 #else
  69 #define FORMAT_ATTR(pos)
  70 #endif
  71 extern void die(const char *, ...) FORMAT_ATTR(1);
  72 extern void info(struct position, const char *, ...) FORMAT_ATTR(2);
  73 extern void warning(struct position, const char *, ...) FORMAT_ATTR(2);
  74 extern void error(struct position, const char *, ...) FORMAT_ATTR(2);
  75 extern void error_die(struct position, const char *, ...) FORMAT_ATTR(2);
  76 #undef FORMAT_ATTR
  77
  78 #define LIST_NODE_NR (29)
  79
  80 struct ptr_list {
  81         int nr;
  82         struct ptr_list *prev;
  83         struct ptr_list *next;
  84         void *list[LIST_NODE_NR];
  85 };
  86
  87 #define ptr_list_empty(x) ((x) == NULL)
  88
  89 void * delete_ptr_list_last(struct ptr_list **head);
  90 int delete_ptr_list_entry(struct ptr_list **, void *, int);
  91 int replace_ptr_list_entry(struct ptr_list **, void *old, void *new, int);
  92 extern void sort_list(struct ptr_list **, int (*)(const void *, const void *));
  93
  94 extern void **__add_ptr_list(struct ptr_list **, void *, unsigned long tag);
  95 extern void concat_ptr_list(struct ptr_list *a, struct ptr_list **b);
  96 extern void __free_ptr_list(struct ptr_list **);
  97 extern int ptr_list_size(struct ptr_list *);
  98 extern char **handle_switch(char *arg, char **next);
  99 extern void add_pre_buffer(const char *fmt, ...);
 100 int linearize_ptr_list(struct ptr_list *, void **, int);
 101
 102 /*
 103  * Hey, who said that you can't do overloading in C?
 104  *
 105  * You just have to be creative, and use some gcc
 106  * extensions..
 107  */
 108 #define add_ptr_list_tag(list,entry,tag) \
 109         (TYPEOF(*(list))) (CHECK_TYPE(*(list),(entry)),__add_ptr_list((struct ptr_list **)(list), (entry), (tag)))
 110 #define add_ptr_list(list,entry) \
 111         add_ptr_list_tag(list,entry,0)
 112 #define free_ptr_list(list) \
 113         do { VRFY_PTR_LIST(*(list)); __free_ptr_list((struct ptr_list **)(list)); } while (0)
 114
 115 extern unsigned int pre_buffer_size;
 116 extern unsigned char pre_buffer[8192];
 117 extern int include_fd;
 118 extern char *include;
 119 extern int preprocess_only;
 120 extern int Wdefault_bitfield_sign;
 121 extern int Wundefined_preprocessor;
 122 extern int Wbitwise, Wtypesign, Wcontext;
 123
 124 extern void declare_builtin_functions(void);
 125 extern void create_builtin_stream(void);
 126 extern struct symbol_list *sparse(int argc, char **argv);
 127
 128 static inline int symbol_list_size(struct symbol_list* list)
 129 {
 130         return ptr_list_size((struct ptr_list *)(list));
 131 }
 132
 133 static inline int statement_list_size(struct statement_list* list)
 134 {
 135         return ptr_list_size((struct ptr_list *)(list));
 136 }
 137
 138 static inline int expression_list_size(struct expression_list* list)
 139 {
 140         return ptr_list_size((struct ptr_list *)(list));
 141 }
 142
 143 static inline int instruction_list_size(struct instruction_list* list)
 144 {
 145         return ptr_list_size((struct ptr_list *)(list));
 146 }
 147
 148 static inline int pseudo_list_size(struct pseudo_list* list)
 149 {
 150         return ptr_list_size((struct ptr_list *)(list));
 151 }
 152
 153 static inline int bb_list_size(struct basic_block_list* list)
 154 {
 155         return ptr_list_size((struct ptr_list *)(list));
 156 }
 157
 158 static inline void free_instruction_list(struct instruction_list **head)
 159 {
 160         free_ptr_list((struct ptr_list **)head);
 161 }
 162
 163 static inline struct instruction * delete_last_instruction(struct instruction_list **head)
 164 {
 165         return delete_ptr_list_last((struct ptr_list **)head);
 166 }
 167
 168 static inline struct basic_block * delete_last_basic_block(struct basic_block_list **head)
 169 {
 170         return delete_ptr_list_last((struct ptr_list **)head);
 171 }
 172
 173 #define PTR_ENTRY(h,i)  (void *)(~3UL & (unsigned long)(h)->list[i])
 174
 175 static inline void *first_ptr_list(struct ptr_list *list)
 176 {
 177         if (!list)
 178                 return NULL;
 179         return PTR_ENTRY(list, 0);
 180 }
 181
 182 static inline void *last_ptr_list(struct ptr_list *list)
 183 {
 184
 185         if (!list)
 186                 return NULL;
 187         list = list->prev;
 188         return PTR_ENTRY(list, list->nr-1);
 189 }
 190
 191 static inline struct basic_block *first_basic_block(struct basic_block_list *head)
 192 {
 193         return first_ptr_list((struct ptr_list *)head);
 194 }
 195 static inline struct instruction *last_instruction(struct instruction_list *head)
 196 {
 197         return last_ptr_list((struct ptr_list *)head);
 198 }
 199
 200 static inline struct instruction *first_instruction(struct instruction_list *head)
 201 {
 202         return first_ptr_list((struct ptr_list *)head);
 203 }
 204
 205 static inline pseudo_t first_pseudo(struct pseudo_list *head)
 206 {
 207         return first_ptr_list((struct ptr_list *)head);
 208 }
 209
 210 static inline void concat_symbol_list(struct symbol_list *from, struct symbol_list **to)
 211 {
 212         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 213 }
 214
 215 static inline void concat_basic_block_list(struct basic_block_list *from, struct basic_block_list **to)
 216 {
 217         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 218 }
 219
 220 static inline void concat_instruction_list(struct instruction_list *from, struct instruction_list **to)
 221 {
 222         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 223 }
 224
 225 static inline void add_symbol(struct symbol_list **list, struct symbol *sym)
 226 {
 227         add_ptr_list(list, sym);
 228 }
 229
 230 static inline void add_statement(struct statement_list **list, struct statement *stmt)
 231 {
 232         add_ptr_list(list, stmt);
 233 }
 234
 235 static inline void add_expression(struct expression_list **list, struct expression *expr)
 236 {
 237         add_ptr_list(list, expr);
 238 }
 239
 240 #define DO_PREPARE(head, ptr, __head, __list, __nr)                                     \
 241         do {                                                                            \
 242                 struct ptr_list *__head = (struct ptr_list *) (head);                   \
 243                 struct ptr_list *__list = __head;                                       \
 244                 int __nr = 0;                                                           \
 245                 CHECK_TYPE(head,ptr);                                                   \
 246                 if (__head) ptr = PTR_ENTRY(__head, 0);                                 \
 247                 else ptr = NULL
 248
 249 #define DO_NEXT(ptr, __head, __list, __nr)                                              \
 250                 if (ptr) {                                                              \
 251                         if (++__nr < __list->nr) {                                      \
 252                                 ptr = PTR_ENTRY(__list,__nr);                           \
 253                         } else {                                                        \
 254                                 __list = __list->next;                                  \
 255                                 ptr = NULL;                                             \
 256                                 if (__list != __head) {                                 \
 257                                         __nr = 0;                                       \
 258                                         ptr = PTR_ENTRY(__list,0);                      \
 259                                 }                                                       \
 260                         }                                                               \
 261                 }
 262
 263 #define DO_RESET(ptr, __head, __list, __nr)                                             \
 264         do {                                                                            \
 265                 __nr = 0;                                                               \
 266                 __list = __head;                                                        \
 267                 if (__head) ptr = PTR_ENTRY(__head, 0);                                 \
 268         } while (0)
 269
 270 #define DO_FINISH(ptr, __head, __list, __nr)                                            \
 271                 (void)(__nr); /* Sanity-check nesting */                                \
 272         } while (0)
 273
 274 #define PREPARE_PTR_LIST(head, ptr) \
 275         DO_PREPARE(head, ptr, __head##ptr, __list##ptr, __nr##ptr)
 276
 277 #define NEXT_PTR_LIST(ptr) \
 278         DO_NEXT(ptr, __head##ptr, __list##ptr, __nr##ptr)
 279
 280 #define RESET_PTR_LIST(ptr) \
 281         DO_RESET(ptr, __head##ptr, __list##ptr, __nr##ptr)
 282
 283 #define FINISH_PTR_LIST(ptr) \
 284         DO_FINISH(ptr, __head##ptr, __list##ptr, __nr##ptr)
 285
 286 #define DO_FOR_EACH(head, ptr, __head, __list, __nr) do {                               \
 287         struct ptr_list *__head = (struct ptr_list *) (head);                           \
 288         struct ptr_list *__list = __head;                                               \
 289         CHECK_TYPE(head,ptr);                                                           \
 290         if (__head) {                                                                   \
 291                 do { int __nr;                                                          \
 292                         for (__nr = 0; __nr < __list->nr; __nr++) {                     \
 293                                 do {                                                    \
 294                                         ptr = PTR_ENTRY(__list,__nr);                   \
 295                                         do {
 296
 297 #define DO_END_FOR_EACH(ptr, __head, __list, __nr)                                      \
 298                                         } while (0);                                    \
 299                                 } while (0);                                            \
 300                         }                                                               \
 301                 } while ((__list = __list->next) != __head);                            \
 302         }                                                                               \
 303 } while (0)
 304
 305 #define DO_FOR_EACH_REVERSE(head, ptr, __head, __list, __nr) do {                       \
 306         struct ptr_list *__head = (struct ptr_list *) (head);                           \
 307         struct ptr_list *__list = __head;                                               \
 308         CHECK_TYPE(head,ptr);                                                           \
 309         if (__head) {                                                                   \
 310                 do { int __nr;                                                          \
 311                         __list = __list->prev;                                          \
 312                         __nr = __list->nr;                                              \
 313                         while (--__nr >= 0) {                                           \
 314                                 do {                                                    \
 315                                         ptr = PTR_ENTRY(__list,__nr);                   \
 316                                         do {
 317
 318
 319 #define DO_END_FOR_EACH_REVERSE(ptr, __head, __list, __nr)                              \
 320                                         } while (0);                                    \
 321                                 } while (0);                                            \
 322                         }                                                               \
 323                 } while (__list != __head);                                             \
 324         }                                                                               \
 325 } while (0)
 326
 327 #define DO_REVERSE(ptr, __head, __list, __nr, new, __newhead, __newlist, __newnr) do {  \
 328         struct ptr_list *__newhead = __head;                                            \
 329         struct ptr_list *__newlist = __list;                                            \
 330         int __newnr = __nr;                                                             \
 331         new = ptr;                                                                      \
 332         goto __inside##new;                                                             \
 333         if (1) {                                                                        \
 334                 do {                                                                    \
 335                         __newlist = __newlist->prev;                                    \
 336                         __newnr = __newlist->nr;                                        \
 337         __inside##new:                                                                  \
 338                         while (--__newnr >= 0) {                                        \
 339                                 do {                                                    \
 340                                         new = PTR_ENTRY(__newlist,__newnr);             \
 341                                         do {
 342
 343 #define RECURSE_PTR_REVERSE(ptr, new)                                                   \
 344         DO_REVERSE(ptr, __head##ptr, __list##ptr, __nr##ptr,                            \
 345                    new, __head##new, __list##new, __nr##new)
 346
 347 #define DO_THIS_ADDRESS(ptr, __head, __list, __nr)                                      \
 348         ((__typeof__(&(ptr))) (__list->list + __nr))
 349
 350 #define FOR_EACH_PTR(head, ptr) \
 351         DO_FOR_EACH(head, ptr, __head##ptr, __list##ptr, __nr##ptr)
 352
 353 #define END_FOR_EACH_PTR(ptr) \
 354         DO_END_FOR_EACH(ptr, __head##ptr, __list##ptr, __nr##ptr)
 355
 356 #define FOR_EACH_PTR_REVERSE(head, ptr) \
 357         DO_FOR_EACH_REVERSE(head, ptr, __head##ptr, __list##ptr, __nr##ptr)
 358
 359 #define END_FOR_EACH_PTR_REVERSE(ptr) \
 360         DO_END_FOR_EACH_REVERSE(ptr, __head##ptr, __list##ptr, __nr##ptr)
 361
 362 #define THIS_ADDRESS(ptr) \
 363         DO_THIS_ADDRESS(ptr, __head##ptr, __list##ptr, __nr##ptr)
 364
 365 extern void split_ptr_list_head(struct ptr_list *);
 366
 367 #define DO_SPLIT(ptr, __head, __list, __nr) do {                                        \
 368         split_ptr_list_head(__list);                                                    \
 369         if (__nr >= __list->nr) {                                                       \
 370                 __nr -= __list->nr;                                                     \
 371                 __list = __list->next;                                                  \
 372         };                                                                              \
 373 } while (0)
 374
 375 #define DO_INSERT_CURRENT(new, ptr, __head, __list, __nr) do {                          \
 376         void **__this, **__last;                                                        \
 377         if (__list->nr == LIST_NODE_NR)                                                 \
 378                 DO_SPLIT(ptr, __head, __list, __nr);                                    \
 379         __this = __list->list + __nr;                                                   \
 380         __last = __list->list + __list->nr - 1;                                         \
 381         while (__last >= __this) {                                                      \
 382                 __last[1] = __last[0];                                                  \
 383                 __last--;                                                               \
 384         }                                                                               \
 385         *__this = (new);                                                                \
 386         __list->nr++;                                                                   \
 387 } while (0)
 388
 389 #define INSERT_CURRENT(new, ptr) \
 390         DO_INSERT_CURRENT(new, ptr, __head##ptr, __list##ptr, __nr##ptr)
 391
 392 #define DO_DELETE_CURRENT(ptr, __head, __list, __nr) do {                               \
 393         void **__this = __list->list + __nr;                                            \
 394         void **__last = __list->list + __list->nr - 1;                                  \
 395         while (__this < __last) {                                                       \
 396                 __this[0] = __this[1];                                                  \
 397                 __this++;                                                               \
 398         }                                                                               \
 399         *__this = (void *)0xf0f0f0f0;                                                   \
 400         __list->nr--; __nr--;                                                           \
 401 } while (0)
 402
 403 #define DELETE_CURRENT_PTR(ptr) \
 404         DO_DELETE_CURRENT(ptr, __head##ptr, __list##ptr, __nr##ptr)
 405
 406 #define REPLACE_CURRENT_PTR(ptr, new_ptr)                                               \
 407         do { *THIS_ADDRESS(ptr) = (new_ptr); } while (0)
 408
 409 extern void pack_ptr_list(struct ptr_list **);
 410
 411 #define PACK_PTR_LIST(x) pack_ptr_list((struct ptr_list **)(x))
 412
 413 #define hashval(x) ((unsigned long)(x))
 414
 415 static inline void update_tag(void *p, unsigned long tag)
 416 {
 417         unsigned long *ptr = p;
 418         *ptr = tag | (~3UL & *ptr);
 419 }
 420
 421 static inline void *tag_ptr(void *ptr, unsigned long tag)
 422 {
 423         return (void *)(tag | (unsigned long)ptr);
 424 }
 425
 426 #define CURRENT_TAG(ptr) (3 & (unsigned long)*THIS_ADDRESS(ptr))
 427 #define TAG_CURRENT(ptr,val)    update_tag(THIS_ADDRESS(ptr),val)
 428
 429 #endif