lib.h

   1 #ifndef LIB_H
   2 #define LIB_H
   3
   4 #include <stdbool.h>
   5 #include <stdlib.h>
   6 #include <stddef.h>
   7
   8 /*
   9  * Basic helper routine descriptions for 'sparse'.
  10  *
  11  * Copyright (C) 2003 Transmeta Corp.
  12  *               2003 Linus Torvalds
  13  *               2004 Christopher Li
  14  *
  15  * Permission is hereby granted, free of charge, to any person obtaining a copy
  16  * of this software and associated documentation files (the "Software"), to deal
  17  * in the Software without restriction, including without limitation the rights
  18  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  19  * copies of the Software, and to permit persons to whom the Software is
  20  * furnished to do so, subject to the following conditions:
  21  *
  22  * The above copyright notice and this permission notice shall be included in
  23  * all copies or substantial portions of the Software.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  28  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  29  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  30  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  31  * THE SOFTWARE.
  32  */
  33
  34 #include "compat.h"
  35 #include "ptrlist.h"
  36 #include "utils.h"
  37 #include "bits.h"
  38 #include "options.h"
  39
  40 #define DO_STRINGIFY(x) #x
  41 #define STRINGIFY(x) DO_STRINGIFY(x)
  42
  43 #ifndef ARRAY_SIZE
  44 #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
  45 #endif
  46
  47 extern int parse_error;
  48
  49 #ifndef PATH_MAX
  50 #define PATH_MAX 4096                   // Hurd doesn't define this
  51 #endif
  52
  53 extern const char *sparse_version;
  54
  55 struct position {
  56         unsigned int type:6,
  57                      stream:14,
  58                      newline:1,
  59                      whitespace:1,
  60                      pos:10;
  61         unsigned int line:31,
  62                      noexpand:1;
  63 };
  64
  65 struct ident;
  66 struct token;
  67 struct symbol;
  68 struct statement;
  69 struct asm_operand;
  70 struct expression;
  71 struct basic_block;
  72 struct entrypoint;
  73 struct instruction;
  74 struct multijmp;
  75 struct pseudo;
  76
  77 DECLARE_PTR_LIST(symbol_list, struct symbol);
  78 DECLARE_PTR_LIST(statement_list, struct statement);
  79 DECLARE_PTR_LIST(asm_operand_list, struct asm_operand);
  80 DECLARE_PTR_LIST(expression_list, struct expression);
  81 DECLARE_PTR_LIST(basic_block_list, struct basic_block);
  82 DECLARE_PTR_LIST(instruction_list, struct instruction);
  83 DECLARE_PTR_LIST(multijmp_list, struct multijmp);
  84 DECLARE_PTR_LIST(pseudo_list, struct pseudo);
  85 DECLARE_PTR_LIST(ident_list, struct ident);
  86 DECLARE_PTR_LIST(string_list, char);
  87
  88 typedef struct pseudo *pseudo_t;
  89
  90 #ifdef __GNUC__
  91 #define FORMAT_ATTR(pos) __attribute__ ((__format__ (__printf__, pos, pos+1)))
  92 #define NORETURN_ATTR __attribute__ ((__noreturn__))
  93 #define SENTINEL_ATTR __attribute__ ((__sentinel__))
  94 #else
  95 #define FORMAT_ATTR(pos)
  96 #define NORETURN_ATTR
  97 #define SENTINEL_ATTR
  98 #endif
  99
 100 FORMAT_ATTR(1) NORETURN_ATTR
 101 extern void die(const char *, ...);
 102
 103 FORMAT_ATTR(2) NORETURN_ATTR
 104 extern void error_die(struct position, const char *, ...);
 105
 106 extern void info(struct position, const char *, ...) FORMAT_ATTR(2);
 107 extern void warning(struct position, const char *, ...) FORMAT_ATTR(2);
 108 extern void sparse_error(struct position, const char *, ...) FORMAT_ATTR(2);
 109 extern void expression_error(struct expression *, const char *, ...) FORMAT_ATTR(2);
 110
 111 #define ERROR_CURR_PHASE        (1 << 0)
 112 #define ERROR_PREV_PHASE        (1 << 1)
 113 extern int has_error;
 114
 115
 116 enum phase {
 117         PASS__PARSE,
 118         PASS__LINEARIZE,
 119         PASS__MEM2REG,
 120         PASS__OPTIM,
 121         PASS__FINAL,
 122 };
 123
 124 #define PASS_PARSE              (1UL << PASS__PARSE)
 125 #define PASS_LINEARIZE          (1UL << PASS__LINEARIZE)
 126 #define PASS_MEM2REG            (1UL << PASS__MEM2REG)
 127 #define PASS_OPTIM              (1UL << PASS__OPTIM)
 128 #define PASS_FINAL              (1UL << PASS__FINAL)
 129
 130
 131 extern void add_pre_buffer(const char *fmt, ...) FORMAT_ATTR(1);
 132 extern void predefine(const char *name, int weak, const char *fmt, ...) FORMAT_ATTR(3);
 133
 134 extern void predefine_strong(const char *name, ...) FORMAT_ATTR(1);
 135 extern void predefine_weak(const char *name, ...) FORMAT_ATTR(1);
 136 extern void predefine_nostd(const char *name);
 137 extern void predefined_macros(void);
 138
 139 extern void dump_macro_definitions(void);
 140 extern struct symbol_list *sparse_initialize(int argc, char **argv, struct string_list **files);
 141 extern struct symbol_list *__sparse(char *filename);
 142 extern struct symbol_list *sparse_keep_tokens(char *filename);
 143 extern struct symbol_list *sparse(char *filename);
 144 extern void report_stats(void);
 145
 146 static inline int symbol_list_size(struct symbol_list *list)
 147 {
 148         return ptr_list_size((struct ptr_list *)(list));
 149 }
 150
 151 static inline int statement_list_size(struct statement_list *list)
 152 {
 153         return ptr_list_size((struct ptr_list *)(list));
 154 }
 155
 156 static inline int expression_list_size(struct expression_list *list)
 157 {
 158         return ptr_list_size((struct ptr_list *)(list));
 159 }
 160
 161 static inline int instruction_list_size(struct instruction_list *list)
 162 {
 163         return ptr_list_size((struct ptr_list *)(list));
 164 }
 165
 166 static inline int pseudo_list_size(struct pseudo_list *list)
 167 {
 168         return ptr_list_size((struct ptr_list *)(list));
 169 }
 170
 171 static inline int bb_list_size(struct basic_block_list *list)
 172 {
 173         return ptr_list_size((struct ptr_list *)(list));
 174 }
 175
 176 static inline void free_instruction_list(struct instruction_list **head)
 177 {
 178         free_ptr_list(head);
 179 }
 180
 181 static inline struct instruction * delete_last_instruction(struct instruction_list **head)
 182 {
 183         return undo_ptr_list_last((struct ptr_list **)head);
 184 }
 185
 186 static inline struct basic_block *first_basic_block(struct basic_block_list *head)
 187 {
 188         return first_ptr_list((struct ptr_list *)head);
 189 }
 190 static inline struct instruction *last_instruction(struct instruction_list *head)
 191 {
 192         return last_ptr_list((struct ptr_list *)head);
 193 }
 194
 195 static inline struct instruction *first_instruction(struct instruction_list *head)
 196 {
 197         return first_ptr_list((struct ptr_list *)head);
 198 }
 199
 200 static inline struct expression *first_expression(struct expression_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 struct symbol *first_symbol(struct symbol_list *head)
 211 {
 212         return first_ptr_list((struct ptr_list *)head);
 213 }
 214
 215 static inline void concat_symbol_list(struct symbol_list *from, struct symbol_list **to)
 216 {
 217         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 218 }
 219
 220 static inline void concat_basic_block_list(struct basic_block_list *from, struct basic_block_list **to)
 221 {
 222         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 223 }
 224
 225 static inline void concat_instruction_list(struct instruction_list *from, struct instruction_list **to)
 226 {
 227         concat_ptr_list((struct ptr_list *)from, (struct ptr_list **)to);
 228 }
 229
 230 static inline void add_symbol(struct symbol_list **list, struct symbol *sym)
 231 {
 232         add_ptr_list(list, sym);
 233 }
 234
 235 static inline void add_statement(struct statement_list **list, struct statement *stmt)
 236 {
 237         add_ptr_list(list, stmt);
 238 }
 239
 240 static inline void add_expression(struct expression_list **list, struct expression *expr)
 241 {
 242         add_ptr_list(list, expr);
 243 }
 244
 245 static inline void add_ident(struct ident_list **list, struct ident *ident)
 246 {
 247         add_ptr_list(list, ident);
 248 }
 249
 250 #define hashval(x) ((unsigned long)(x))
 251
 252 #endif