lib.h

   1 #ifndef LIB_H
   2 #define LIB_H
   3 /*
   4  * Basic helper routine descriptions for 'sparse'.
   5  *
   6  * Copyright (C) 2003 Transmeta Corp.
   7  *               2003 Linus Torvalds
   8  *               2004 Christopher Li
   9  *
  10  *  Licensed under the Open Software License version 1.1
  11  */
  12
  13 extern unsigned int hexval(unsigned int c);
  14
  15 struct position {
  16         unsigned int type:6,
  17                      stream:10,
  18                      pos:14,
  19                      newline:1,
  20                      whitespace:1;
  21         unsigned int line:31,
  22                      noexpand:1;
  23 };
  24
  25 struct ident;
  26 struct token;
  27 struct symbol;
  28 struct symbol_list;
  29 struct statement;
  30 struct statement_list;
  31 struct expression;
  32 struct expression_list;
  33 struct basic_block;
  34 struct basic_block_list;
  35 struct entrypoint;
  36 struct instruction;
  37 struct instruction_list;
  38 struct multijmp;
  39 struct multijmp_list;
  40 struct phi;
  41 struct phi_list;
  42
  43 struct token *skip_to(struct token *, int);
  44 struct token *expect(struct token *, int, const char *);
  45 extern void info(struct position, const char *, ...);
  46 extern void warn(struct position, const char *, ...);
  47 extern void error(struct position, const char *, ...);
  48
  49 #define __DECLARE_ALLOCATOR(type, x)            \
  50         extern type *__alloc_##x(int);          \
  51         extern void show_##x##_alloc(void);     \
  52         extern void clear_##x##_alloc(void);
  53 #define DECLARE_ALLOCATOR(x) __DECLARE_ALLOCATOR(struct x, x)
  54
  55 DECLARE_ALLOCATOR(ident);
  56 DECLARE_ALLOCATOR(token);
  57 DECLARE_ALLOCATOR(symbol);
  58 DECLARE_ALLOCATOR(expression);
  59 DECLARE_ALLOCATOR(statement);
  60 DECLARE_ALLOCATOR(string);
  61 DECLARE_ALLOCATOR(scope);
  62 __DECLARE_ALLOCATOR(void, bytes);
  63 DECLARE_ALLOCATOR(basic_block);
  64 DECLARE_ALLOCATOR(entrypoint);
  65 DECLARE_ALLOCATOR(instruction);
  66 DECLARE_ALLOCATOR(multijmp);
  67 DECLARE_ALLOCATOR(phi);
  68 DECLARE_ALLOCATOR(pseudo);
  69
  70
  71 #define LIST_NODE_NR (29)
  72
  73 struct ptr_list {
  74         int nr;
  75         struct ptr_list *prev;
  76         struct ptr_list *next;
  77         void *list[LIST_NODE_NR];
  78 };
  79
  80 struct list_iterator {
  81         struct ptr_list **head;
  82         struct ptr_list *active;
  83         int index;
  84         unsigned int flags;
  85 };
  86
  87 enum iterator_br_state {
  88         BR_INIT,
  89         BR_TRUE,
  90         BR_FALSE,
  91         BR_END,
  92 };
  93
  94 struct terminator_iterator {
  95         struct instruction *terminator;
  96         union {
  97                 struct list_iterator multijmp;
  98                 int branch;
  99         };
 100 };
 101
 102 #define ITERATOR_BACKWARDS 1
 103 #define ITERATOR_CURRENT 2
 104
 105 #define ITERATE_FIRST 1
 106 #define ITERATE_LAST 2
 107
 108 #define ptr_list_empty(x) ((x) == NULL)
 109
 110 void iterate(struct ptr_list *,void (*callback)(void *, void *, int), void*);
 111 void init_iterator(struct ptr_list **head, struct list_iterator *iterator, int flags);
 112 void * next_iterator(struct list_iterator *iterator);
 113 void delete_iterator(struct list_iterator *iterator);
 114 void init_terminator_iterator(struct instruction* terminator, struct terminator_iterator *iterator);
 115 struct basic_block* next_terminator_bb(struct terminator_iterator *iterator);
 116 void replace_terminator_bb(struct terminator_iterator *iterator, struct basic_block* bb);
 117 void * delete_ptr_list_last(struct ptr_list **head);
 118 int replace_ptr_list(struct ptr_list **head, void *old_ptr, void *new_ptr);
 119
 120 extern void add_ptr_list(struct ptr_list **, void *);
 121 extern void concat_ptr_list(struct ptr_list *a, struct ptr_list **b);
 122 extern void free_ptr_list(struct ptr_list **);
 123 extern int ptr_list_size(struct ptr_list *);
 124 extern char **handle_switch(char *arg, char **next);
 125 extern void add_pre_buffer(const char *fmt, ...);
 126 void * next_iterator(struct list_iterator *iterator);
 127
 128 extern unsigned int pre_buffer_size;
 129 extern unsigned char pre_buffer[8192];
 130 extern int include_fd;
 131 extern char *include;
 132 extern int preprocess_only;
 133 extern int Wdefault_bitfield_sign;
 134
 135 extern void create_builtin_stream(void);
 136
 137 static inline int symbol_list_size(struct symbol_list* list)
 138 {
 139         return ptr_list_size((struct ptr_list *)(list));
 140 }
 141
 142 static inline int statement_list_size(struct statement_list* list)
 143 {
 144         return ptr_list_size((struct ptr_list *)(list));
 145 }
 146
 147 static inline int expression_list_size(struct expression_list* list)
 148 {
 149         return ptr_list_size((struct ptr_list *)(list));
 150 }
 151
 152 static inline int instruction_list_size(struct instruction_list* list)
 153 {
 154         return ptr_list_size((struct ptr_list *)(list));
 155 }
 156
 157 static inline int phi_list_size(struct phi_list* list)
 158 {
 159         return ptr_list_size((struct ptr_list *)(list));
 160 }
 161
 162 static inline int bb_list_size(struct basic_block_list* list)
 163 {
 164         return ptr_list_size((struct ptr_list *)(list));
 165 }
 166
 167 static inline struct basic_block* next_basic_block(struct list_iterator *iterator)
 168 {
 169         return  next_iterator(iterator);
 170 }
 171
 172 static inline struct multijmp* next_multijmp(struct list_iterator *iterator)
 173 {
 174         return  next_iterator(iterator);
 175 }
 176
 177 static inline void free_instruction_list(struct instruction_list **head)
 178 {
 179         free_ptr_list((struct ptr_list **)head);
 180 }
 181
 182 static inline void init_multijmp_iterator(struct multijmp_list **head, struct list_iterator *iterator, int flags)
 183 {
 184         init_iterator((struct ptr_list **)head, iterator, flags);
 185 }
 186
 187 static inline void init_bb_iterator(struct basic_block_list **head, struct list_iterator *iterator, int flags)
 188 {
 189         init_iterator((struct ptr_list **)head, iterator, flags);
 190 }
 191
 192 static inline struct instruction * delete_last_instruction(struct instruction_list **head)
 193 {
 194         return delete_ptr_list_last((struct ptr_list **)head);
 195 }
 196
 197 static inline struct basic_block * delete_last_basic_block(struct basic_block_list **head)
 198 {
 199         return delete_ptr_list_last((struct ptr_list **)head);
 200 }
 201
 202 static inline void *first_ptr_list(struct ptr_list *list)
 203 {
 204         if (!list)
 205                 return NULL;
 206         return list->list[0];
 207 }
 208
 209 static inline void *last_ptr_list(struct ptr_list *list)
 210 {
 211
 212         if (!list)
 213                 return NULL;
 214         list = list->prev;
 215         return list->list[list->nr-1];
 216 }
 217
 218 static inline void * current_iterator(struct list_iterator *iterator)
 219 {
 220         struct ptr_list *list = iterator->active;
 221         return list ? list->list[iterator->index] : NULL;
 222 }
 223
 224 static inline struct basic_block *first_basic_block(struct basic_block_list *head)
 225 {
 226         return last_ptr_list((struct ptr_list *)head);
 227 }
 228 static inline struct instruction *last_instruction(struct instruction_list *head)
 229 {
 230         return last_ptr_list((struct ptr_list *)head);
 231 }
 232
 233 static inline struct instruction *first_instruction(struct instruction_list *head)
 234 {
 235         return first_ptr_list((struct ptr_list *)head);
 236 }
 237
 238 static inline struct phi *first_phi(struct phi_list *head)
 239 {
 240         return first_ptr_list((struct ptr_list *)head);
 241 }
 242
 243 static inline int replace_basic_block_list(struct basic_block_list **head, struct basic_block *from, struct basic_block *to)
 244 {
 245         return replace_ptr_list((struct ptr_list **)head, (void*)from, (void*)to);
 246 }
 247
 248 static inline void concat_symbol_list(struct symbol_list *from, struct symbol_list **to)
 249 {
 250         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 251 }
 252
 253 static inline void concat_basic_block_list(struct basic_block_list *from, struct basic_block_list **to)
 254 {
 255         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 256 }
 257
 258 static inline void concat_instruction_list(struct instruction_list *from, struct instruction_list **to)
 259 {
 260         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 261 }
 262
 263 static inline void add_symbol(struct symbol_list **list, struct symbol *sym)
 264 {
 265         add_ptr_list((struct ptr_list **)list, sym);
 266 }
 267
 268 static inline void add_statement(struct statement_list **list, struct statement *stmt)
 269 {
 270         add_ptr_list((struct ptr_list **)list, stmt);
 271 }
 272
 273 static inline void add_expression(struct expression_list **list, struct expression *expr)
 274 {
 275         add_ptr_list((struct ptr_list **)list, expr);
 276 }
 277
 278 static inline void symbol_iterate(struct symbol_list *list, void (*callback)(struct symbol *, void *, int), void *data)
 279 {
 280         iterate((struct ptr_list *)list, (void (*)(void *, void *, int))callback, data);
 281 }
 282
 283 static inline void statement_iterate(struct statement_list *list, void (*callback)(struct statement *, void *, int), void *data)
 284 {
 285         iterate((struct ptr_list *)list, (void (*)(void *, void *, int))callback, data);
 286 }
 287
 288 static inline void expression_iterate(struct expression_list *list, void (*callback)(struct expression *, void *, int), void *data)
 289 {
 290         iterate((struct ptr_list *)list, (void (*)(void *, void *, int))callback, data);
 291 }
 292
 293 #define PREPARE_PTR_LIST(head, ptr)                                                     \
 294         do {                                                                            \
 295                 struct ptr_list *__head##ptr = (struct ptr_list *) (head);              \
 296                 struct ptr_list *__list##ptr = __head##ptr;                             \
 297                 int __nr##ptr = 0;                                                      \
 298                 if (__head##ptr) ptr = (__typeof__(ptr)) __head##ptr->list[0];          \
 299                 else ptr = NULL
 300
 301 #define NEXT_PTR_LIST(ptr)                                                      \
 302                 if (ptr) {                                                              \
 303                         if (++__nr##ptr < __list##ptr->nr) {                            \
 304                                 ptr = (__typeof__(ptr)) __list##ptr->list[__nr##ptr];   \
 305                         } else {                                                        \
 306                                 __list##ptr = __list##ptr->next;                        \
 307                                 ptr = NULL;                                             \
 308                                 if (__list##ptr != __head##ptr) {                       \
 309                                         __nr##ptr = 0;                                  \
 310                                         ptr = (__typeof__(ptr)) __list##ptr->list[0];   \
 311                                 }                                                       \
 312                         }                                                               \
 313                 }
 314
 315 #define RESET_PTR_LIST(ptr) do {                                                        \
 316                 __nr##ptr = 0;                                                          \
 317                 __list##ptr = __head##ptr;                                              \
 318                 if (__head##ptr) ptr = (__typeof__(ptr)) __head##ptr->list[0];          \
 319         } while (0)
 320
 321
 322 #define FINISH_PTR_LIST(ptr)                                                            \
 323                 (void)(__nr##ptr); /* Sanity-check nesting */                           \
 324         } while (0)
 325
 326 #define FOR_EACH_PTR(head, ptr) do {                                                    \
 327         struct ptr_list *__head = (struct ptr_list *) (head);                           \
 328         struct ptr_list *__list = __head;                                               \
 329         int __flag = ITERATE_FIRST;                                                     \
 330         if (__head) {                                                                   \
 331                 do { int __i;                                                           \
 332                         for (__i = 0; __i < __list->nr; __i++) {                        \
 333                                 if (__i == __list->nr-1 && __list->next == __head)      \
 334                                         __flag |= ITERATE_LAST;                         \
 335                                 do {                                                    \
 336                                         ptr = (__typeof__(ptr)) (__list->list[__i]);    \
 337                                         do {
 338
 339 #define END_FOR_EACH_PTR                } while (0);                                    \
 340                                 } while (0);                                            \
 341                                 __flag = 0;                                             \
 342                         }                                                               \
 343                 } while ((__list = __list->next) != __head);                            \
 344         }                                                                               \
 345 } while (0)
 346
 347 #define FOR_EACH_PTR_REVERSE(head, ptr) do {                                            \
 348         struct ptr_list *__head = (struct ptr_list *) (head);                           \
 349         struct ptr_list *__list = __head;                                               \
 350         int __flag = ITERATE_FIRST;                                                     \
 351         if (__head) {                                                                   \
 352                 do { int __i;                                                           \
 353                         __list = __list->prev;                                          \
 354                         __i = __list->nr;                                               \
 355                         while (--__i >= 0) {                                            \
 356                                 if (__i == 0 && __list == __head)                       \
 357                                         __flag |= ITERATE_LAST;                         \
 358                                 do {                                                    \
 359                                         ptr = (__typeof__(ptr)) (__list->list[__i]);    \
 360                                         do {
 361
 362 #define END_FOR_EACH_PTR_REVERSE        } while (0);                                    \
 363                                 } while (0);                                            \
 364                                 __flag = 0;                                             \
 365                         }                                                               \
 366                 } while (__list != __head);                                             \
 367         }                                                                               \
 368 } while (0)
 369
 370 #define THIS_ADDRESS(x) \
 371         ((__typeof__(&(x))) (__list->list + __i))
 372
 373 #endif