sparse-llvm.c

   1 /*
   2  * Example usage:
   3  *      ./sparse-llvm hello.c | llc | as -o hello.o
   4  */
   5
   6 #include <llvm-c/Core.h>
   7 #include <llvm-c/BitWriter.h>
   8
   9 #include <stdio.h>
  10 #include <unistd.h>
  11 #include <assert.h>
  12
  13 #include "symbol.h"
  14 #include "expression.h"
  15 #include "linearize.h"
  16 #include "flow.h"
  17
  18 struct function {
  19         LLVMBuilderRef                  builder;
  20         LLVMTypeRef                     type;
  21         LLVMValueRef                    fn;
  22 };
  23
  24 static LLVMTypeRef symbol_type(struct symbol *sym)
  25 {
  26         LLVMTypeRef ret = NULL;
  27
  28         switch (sym->bit_size) {
  29         case -1:
  30                 ret = LLVMVoidType();
  31                 break;
  32         case 8:
  33                 ret = LLVMInt8Type();
  34                 break;
  35         case 16:
  36                 ret = LLVMInt16Type();
  37                 break;
  38         case 32:
  39                 ret = LLVMInt32Type();
  40                 break;
  41         case 64:
  42                 ret = LLVMInt64Type();
  43                 break;
  44         default:
  45                 die("invalid bit size %d for type %d", sym->bit_size, sym->type);
  46                 break;
  47         };
  48
  49         return ret;
  50 }
  51
  52 static LLVMLinkage data_linkage(struct symbol *sym)
  53 {
  54         if (sym->ctype.modifiers & MOD_STATIC)
  55                 return LLVMPrivateLinkage;
  56
  57         return LLVMExternalLinkage;
  58 }
  59
  60 static LLVMLinkage function_linkage(struct symbol *sym)
  61 {
  62         if (sym->ctype.modifiers & MOD_STATIC)
  63                 return LLVMInternalLinkage;
  64
  65         return LLVMExternalLinkage;
  66 }
  67
  68 static void output_op_ret(struct function *fn, struct instruction *insn)
  69 {
  70         pseudo_t pseudo = insn->src;
  71
  72         if (pseudo && pseudo != VOID) {
  73                 switch (pseudo->type) {
  74                 case PSEUDO_REG:
  75                         assert(0);
  76                         break;
  77                 case PSEUDO_SYM:
  78                         assert(0);
  79                         break;
  80                 case PSEUDO_VAL:
  81                         LLVMBuildRet(fn->builder, LLVMConstInt(LLVMGetReturnType(fn->type), pseudo->value, 1));
  82                         break;
  83                 case PSEUDO_ARG: {
  84                         LLVMValueRef param = LLVMGetParam(fn->fn, pseudo->nr - 1);
  85                         LLVMBuildRet(fn->builder, param);
  86                         break;
  87                 }
  88                 case PSEUDO_PHI:
  89                         assert(0);
  90                         break;
  91                 default:
  92                         assert(0);
  93                 }
  94         } else
  95                 LLVMBuildRetVoid(fn->builder);
  96 }
  97
  98 static void output_insn(struct function *fn, struct instruction *insn)
  99 {
 100         switch (insn->opcode) {
 101         case OP_RET:
 102                 output_op_ret(fn, insn);
 103                 break;
 104         case OP_BR:
 105                 break;
 106         case OP_SYMADDR:
 107                 break;
 108         case OP_SETVAL:
 109                 break;
 110         case OP_SWITCH:
 111                 break;
 112         case OP_COMPUTEDGOTO:
 113                 break;
 114         case OP_PHISOURCE:
 115                 break;
 116         case OP_PHI:
 117                 break;
 118         case OP_LOAD: case OP_LNOP:
 119                 break;
 120         case OP_STORE: case OP_SNOP:
 121                 break;
 122         case OP_INLINED_CALL:
 123         case OP_CALL:
 124                 break;
 125         case OP_CAST:
 126         case OP_SCAST:
 127         case OP_FPCAST:
 128         case OP_PTRCAST:
 129                 break;
 130         case OP_BINARY ... OP_BINARY_END:
 131         case OP_BINCMP ... OP_BINCMP_END:
 132                 break;
 133         case OP_SEL:
 134                 break;
 135         case OP_SLICE:
 136                 break;
 137         case OP_NOT: case OP_NEG:
 138                 break;
 139         case OP_CONTEXT:
 140                 break;
 141         case OP_RANGE:
 142                 break;
 143         case OP_NOP:
 144                 break;
 145         case OP_DEATHNOTE:
 146                 break;
 147         case OP_ASM:
 148                 break;
 149         case OP_COPY:
 150                 break;
 151         default:
 152                 break;
 153         }
 154 }
 155
 156 static void output_bb(struct function *fn, struct basic_block *bb, unsigned long generation)
 157 {
 158         struct instruction *insn;
 159
 160         bb->generation = generation;
 161
 162         FOR_EACH_PTR(bb->insns, insn) {
 163                 if (!insn->bb)
 164                         continue;
 165
 166                 output_insn(fn, insn);
 167         }
 168         END_FOR_EACH_PTR(insn);
 169 }
 170
 171 #define MAX_ARGS        64
 172
 173 static void output_fn(LLVMModuleRef module, struct entrypoint *ep)
 174 {
 175         unsigned long generation = ++bb_generation;
 176         struct symbol *sym = ep->name;
 177         struct symbol *base_type = sym->ctype.base_type;
 178         struct symbol *ret_type = sym->ctype.base_type->ctype.base_type;
 179         LLVMTypeRef arg_types[MAX_ARGS];
 180         LLVMTypeRef return_type;
 181         struct function function;
 182         struct basic_block *bb;
 183         struct symbol *arg;
 184         const char *name;
 185         int nr_args = 0;
 186
 187         FOR_EACH_PTR(base_type->arguments, arg) {
 188                 struct symbol *arg_base_type = arg->ctype.base_type;
 189
 190                 arg_types[nr_args++] = symbol_type(arg_base_type);
 191         } END_FOR_EACH_PTR(arg);
 192
 193         name = show_ident(sym->ident);
 194
 195         return_type = symbol_type(ret_type);
 196
 197         function.type = LLVMFunctionType(return_type, arg_types, nr_args, 0);
 198
 199         function.fn = LLVMAddFunction(module, name, function.type);
 200
 201         LLVMSetLinkage(function.fn, function_linkage(sym));
 202
 203         unssa(ep);
 204
 205         function.builder = LLVMCreateBuilder();
 206
 207         LLVMBasicBlockRef entry = LLVMAppendBasicBlock(function.fn, "entry");
 208
 209         LLVMPositionBuilderAtEnd(function.builder, entry);
 210
 211         FOR_EACH_PTR(ep->bbs, bb) {
 212                 if (bb->generation == generation)
 213                         continue;
 214
 215                 output_bb(&function, bb, generation);
 216         }
 217         END_FOR_EACH_PTR(bb);
 218 }
 219
 220 static int output_data(LLVMModuleRef module, struct symbol *sym)
 221 {
 222         struct expression *initializer = sym->initializer;
 223         unsigned long long initial_value = 0;
 224         LLVMValueRef data;
 225         const char *name;
 226
 227         if (initializer) {
 228                 if (initializer->type == EXPR_VALUE)
 229                         initial_value = initializer->value;
 230                 else
 231                         assert(0);
 232         }
 233
 234         name = show_ident(sym->ident);
 235
 236         data = LLVMAddGlobal(module, symbol_type(sym->ctype.base_type), name);
 237
 238         LLVMSetLinkage(data, data_linkage(sym));
 239
 240         LLVMSetInitializer(data, LLVMConstInt(symbol_type(sym), initial_value, 1));
 241
 242         return 0;
 243 }
 244
 245 static int compile(LLVMModuleRef module, struct symbol_list *list)
 246 {
 247         struct symbol *sym;
 248
 249         FOR_EACH_PTR(list, sym) {
 250                 struct entrypoint *ep;
 251                 expand_symbol(sym);
 252                 ep = linearize_symbol(sym);
 253                 if (ep)
 254                         output_fn(module, ep);
 255                 else
 256                         output_data(module, sym);
 257         }
 258         END_FOR_EACH_PTR(sym);
 259
 260         return 0;
 261 }
 262
 263 int main(int argc, char **argv)
 264 {
 265         struct string_list * filelist = NULL;
 266         char *file;
 267
 268         LLVMModuleRef module = LLVMModuleCreateWithName("sparse");
 269
 270         compile(module, sparse_initialize(argc, argv, &filelist));
 271
 272         FOR_EACH_PTR_NOTAG(filelist, file) {
 273                 compile(module, sparse(file));
 274         } END_FOR_EACH_PTR_NOTAG(file);
 275
 276 #if 1
 277         LLVMWriteBitcodeToFD(module, STDOUT_FILENO, 0, 0);
 278 #else
 279         LLVMDumpModule(module);
 280 #endif
 281
 282         LLVMDisposeModule(module);
 283
 284         return 0;
 285 }