src/ast/llvm-generator-visitor.cc

   1 #include <iomanip>
   2
   3 #include <core/assert.hh>
   4
   5 #include "llvm-generator-visitor.hh"
   6
   7 namespace ast
   8 {
   9   LLVMGeneratorVisitor::LLVMGeneratorVisitor(std::ostream & out)
  10     : super_t(),
  11       castTable_(),
  12       out_(out)
  13   {
  14     assert_msg(out.good(), "The output for llvm assembly is not valid.");
  15
  16     //out_.setf(std::ios::hex, std::ios::basefield);
  17     //out_.setf(std::ios::showbase);
  18
  19
  20 #define ADD_CAST_TABLE_ENTRY(Type1, Type2)                              \
  21     do {                                                                \
  22       castTableKey_t key = std::make_pair(Type1##Type::nodeTypeId(),    \
  23                                           Type2##Type::nodeTypeId());   \
  24       assert_msg(!castTable_.count(key),                                \
  25                  "the same key has been insterted two times");          \
  26       castTable_[key] = &LLVMGeneratorVisitor::cast##Type1##To##Type2;  \
  27     } while (0)
  28
  29     ADD_CAST_TABLE_ENTRY(Bool, Bool);
  30     ADD_CAST_TABLE_ENTRY(Bool, Integer);
  31     ADD_CAST_TABLE_ENTRY(Bool, Float);
  32     ADD_CAST_TABLE_ENTRY(Bool, Double);
  33     ADD_CAST_TABLE_ENTRY(Integer, Bool);
  34     ADD_CAST_TABLE_ENTRY(Integer, Integer);
  35     ADD_CAST_TABLE_ENTRY(Integer, Float);
  36     ADD_CAST_TABLE_ENTRY(Integer, Double);
  37     ADD_CAST_TABLE_ENTRY(Float, Double);
  38     ADD_CAST_TABLE_ENTRY(Float, Bool);
  39     ADD_CAST_TABLE_ENTRY(Double, Bool);
  40   }
  41
  42   LLVMGeneratorVisitor::~LLVMGeneratorVisitor()
  43   {
  44   }
  45
  46   void
  47   LLVMGeneratorVisitor::visit(const Function & node)
  48   {
  49     out_ << "define void @" << node.name << "() {" << std::endl;
  50     super_t::visit(node);
  51     out_ << "  ret void" << std::endl
  52          << "}" << std::endl;
  53   }
  54
  55   void
  56   LLVMGeneratorVisitor::visit(const VarDecl & node)
  57   {
  58     assert(node.type);
  59
  60     out_ << "  %" << node.name << " = alloca ";
  61     node.type->accept(*this);
  62     out_ << std::endl;
  63   }
  64
  65   void
  66   LLVMGeneratorVisitor::visit(const LoadVar & node)
  67   {
  68     assert(node.type);
  69
  70     out_ << "  %" << node.to << " = load ";
  71     node.type->accept(*this);
  72     out_ << " * %" << node.name << std::endl;
  73   }
  74
  75   void
  76   LLVMGeneratorVisitor::visit(const StoreVar & node)
  77   {
  78     assert(node.value);
  79     assert(node.value->type);
  80
  81     out_ << "  store ";
  82     node.value->type->accept(*this);
  83     node.value->accept(*this);
  84     out_ << ", ";
  85     node.value->type->accept(*this);
  86     out_ << " * %" << node.name << std::endl;
  87   }
  88
  89   void
  90   LLVMGeneratorVisitor::visit(const AssignExp & node)
  91   {
  92     out_ << "  %" << node.dest->name << " = ";
  93     node.value->accept(*this);
  94     out_ << std::endl;
  95   }
  96
  97 #define GEN_BINARY_EXP_EXT(Name, Type, Instr)   \
  98   void                                          \
  99   LLVMGeneratorVisitor::Name(const Type & node) \
 100   {                                             \
 101     out_ << Instr" ";                           \
 102     node.type->accept(*this);                   \
 103     node.left->accept(*this);                   \
 104     out_ << ", ";                               \
 105     node.right->accept(*this);                  \
 106   }
 107
 108 #define GEN_BINARY_EXP(Type, Instr) GEN_BINARY_EXP_EXT(visit, Type, Instr)
 109
 110   GEN_BINARY_EXP(AddExp, "add")
 111   GEN_BINARY_EXP(SubExp, "sub")
 112   GEN_BINARY_EXP(MulExp, "mul")
 113   GEN_BINARY_EXP_EXT(visitUDivExp, DivExp, "udiv")
 114   GEN_BINARY_EXP_EXT(visitSDivExp, DivExp, "sdiv")
 115   GEN_BINARY_EXP_EXT(visitFDivExp, DivExp, "fdiv")
 116   GEN_BINARY_EXP_EXT(visitUModExp, ModExp, "urem")
 117   GEN_BINARY_EXP_EXT(visitSModExp, ModExp, "srem")
 118   GEN_BINARY_EXP_EXT(visitFModExp, ModExp, "frem")
 119
 120   GEN_BINARY_EXP(AndExp, "and")
 121   GEN_BINARY_EXP(OrExp, "or")
 122   GEN_BINARY_EXP(XorExp, "xor")
 123
 124   GEN_BINARY_EXP(ShlExp, "shl")
 125   GEN_BINARY_EXP(AShrExp, "ashr")
 126   GEN_BINARY_EXP(LShrExp, "lshr")
 127
 128   /// @todo check this is correct.
 129 #define GEN_CMP_EXP(Type, Instr)                                        \
 130   void                                                                  \
 131   LLVMGeneratorVisitor::visit(const Type & node)                        \
 132   {                                                                     \
 133     if (node.type->nodeType == FloatType::nodeTypeId() ||               \
 134         node.type->nodeType == DoubleType::nodeTypeId())                \
 135       out_ << "fcmp o";                                                 \
 136     else                                                                \
 137     {                                                                   \
 138       out_ << "icmp ";                                                  \
 139       if (node.nodeType == LtExp::nodeTypeId() ||                       \
 140           node.nodeType == LtEqExp::nodeTypeId() ||                     \
 141           node.nodeType == GtExp::nodeTypeId() ||                       \
 142           node.nodeType == GtEqExp::nodeTypeId())                       \
 143       {                                                                 \
 144         if (node.type->nodeType == IntegerType::nodeTypeId())           \
 145         {                                                               \
 146           IntegerType * itype = reinterpret_cast<IntegerType *>(node.type); \
 147           out_ << (itype->isSigned ? "s" : "u");                        \
 148         }                                                               \
 149         else if (node.type->nodeType == BoolType::nodeTypeId())         \
 150           out_ << "u";                                                  \
 151       }                                                                 \
 152     }                                                                   \
 153     out_ << Instr" ";                                                   \
 154     node.type->accept(*this);                                           \
 155     node.left->accept(*this);                                           \
 156     out_ << ", ";                                                       \
 157     node.right->accept(*this);                                          \
 158   }
 159
 160   GEN_CMP_EXP(EqExp, "eq")
 161   GEN_CMP_EXP(NeqExp, "ne")
 162   GEN_CMP_EXP(LtExp, "lt")
 163   GEN_CMP_EXP(LtEqExp, "le")
 164   GEN_CMP_EXP(GtExp, "gt")
 165   GEN_CMP_EXP(GtEqExp, "ge")
 166
 167 #define GEN_BINARY_BOOL_EXP(Type, Op)                   \
 168   void                                                  \
 169   LLVMGeneratorVisitor::visit(const Type & node)        \
 170   {                                                     \
 171     out_ << Op " i1 ";                                  \
 172     node.left->accept(*this);                           \
 173     out_ << ", ";                                       \
 174     node.right->accept(*this);                          \
 175   }
 176
 177   GEN_BINARY_BOOL_EXP(AndAndExp, "and ")
 178   GEN_BINARY_BOOL_EXP(OrOrExp, "or ")
 179
 180 #define GEN_DIV_MOD_EXP(Name)                                           \
 181   void                                                                  \
 182   LLVMGeneratorVisitor::visit(const Name##Exp & node)                   \
 183   {                                                                     \
 184     if (node.type->nodeType == BoolType::nodeTypeId())                  \
 185       visitU##Name##Exp(node);                                          \
 186     else if (node.type->nodeType == FloatType::nodeTypeId() ||          \
 187              node.type->nodeType == DoubleType::nodeTypeId())           \
 188       visitF##Name##Exp(node);                                          \
 189     else if (node.type->nodeType == IntegerType::nodeTypeId())          \
 190     {                                                                   \
 191       IntegerType * type = reinterpret_cast<IntegerType *>(node.type);  \
 192       type->isSigned ? visitS##Name##Exp(node) : visitU##Name##Exp(node); \
 193     }                                                                   \
 194     else                                                                \
 195       assert(false);                                                    \
 196   }
 197
 198   GEN_DIV_MOD_EXP(Div)
 199   GEN_DIV_MOD_EXP(Mod)
 200
 201   // void
 202   // LLVMGeneratorVisitor::visit(const EqExp & node)
 203   // {
 204
 205   // }
 206
 207   void
 208   LLVMGeneratorVisitor::visit(const IdExp & node)
 209   {
 210     out_ << "%" << node.name;
 211   }
 212
 213   void
 214   LLVMGeneratorVisitor::visit(const TmpResultExp & node)
 215   {
 216     out_ << "%" << node.name;
 217   }
 218
 219   void
 220   LLVMGeneratorVisitor::visit(const NumberExp & node)
 221   {
 222     if (node.type->nodeType == FloatType::nodeTypeId())
 223       /// @todo find the right way to print floating point numbers
 224       out_ << std::setprecision(1000) << (float)node.number;
 225     else
 226       out_ << std::setprecision(1000) << node.number;
 227   }
 228
 229   void
 230   LLVMGeneratorVisitor::visit(const Label & node)
 231   {
 232     out_ << "  br label %" << node.name << " ; dummy branch to start a block" << std::endl
 233          << node.name << ":" << std::endl;
 234   }
 235
 236   void
 237   LLVMGeneratorVisitor::visit(const Goto & node)
 238   {
 239     out_ << "  br label %" << node.label << std::endl;
 240   }
 241
 242   void
 243   LLVMGeneratorVisitor::visit(const If & node)
 244   {
 245     assert(node.ifTrue->nodeType == Label::nodeTypeId());
 246     assert(node.ifFalse->nodeType == Label::nodeTypeId());
 247
 248     Label * trueLabel = reinterpret_cast<Label *>(node.ifTrue);
 249     Label * falseLabel = reinterpret_cast<Label *>(node.ifFalse);
 250
 251     out_ << "  br i1 ";
 252     node.cond->accept(*this);
 253     out_ << ", label %" << trueLabel->name << ", label %"
 254          << falseLabel->name << std::endl;
 255   }
 256
 257   void
 258   LLVMGeneratorVisitor::visit(const Type & /*node*/)
 259   {
 260     //assert_msg(false, "we should never reach this code");
 261   }
 262
 263   void
 264   LLVMGeneratorVisitor::visit(const NumberType & /*node*/)
 265   {
 266     assert_msg(false, "we should never reach this code");
 267   }
 268
 269   void
 270   LLVMGeneratorVisitor::visit(const BoolType & /*node*/)
 271   {
 272     out_ << " i1 ";
 273   }
 274
 275   void
 276   LLVMGeneratorVisitor::visit(const IntegerType & node)
 277   {
 278     out_ << " i" << node.size << " ";
 279   }
 280
 281   void
 282   LLVMGeneratorVisitor::visit(const FloatType & /*node*/)
 283   {
 284     out_ << " float ";
 285   }
 286
 287   void
 288   LLVMGeneratorVisitor::visit(const DoubleType & /*node*/)
 289   {
 290     out_ << " double ";
 291   }
 292
 293   void
 294   LLVMGeneratorVisitor::visit(const CastExp & node)
 295   {
 296     Type * from = node.exp->type;
 297     Type * to = node.type;
 298
 299     assert(from);
 300     assert(to);
 301     castTableKey_t key = std::make_pair(from->nodeType, to->nodeType);
 302     assert(castTable_.count(key) > 0);
 303     (this->*castTable_[key])(node);
 304   }
 305
 306   void
 307   LLVMGeneratorVisitor::castBoolToBool(const CastExp & node)
 308   {
 309     out_ << "add i1 0, ";
 310     node.exp->accept(*this);
 311     return;
 312   }
 313
 314 #define SIMPLE_NUMBER_CAST(Type1, Type2, CastInstr, DestType)           \
 315   void                                                                  \
 316   LLVMGeneratorVisitor::cast##Type1##To##Type2(const CastExp & node)    \
 317   {                                                                     \
 318     out_ << CastInstr;                                                  \
 319     node.exp->accept(*this);                                            \
 320     out_ << DestType;                                                   \
 321     return;                                                             \
 322   }
 323
 324   SIMPLE_NUMBER_CAST(Bool, Float, "uitofp i1 ", " to float")
 325   SIMPLE_NUMBER_CAST(Bool, Double, "uitofp i1 ", " to double")
 326   SIMPLE_NUMBER_CAST(Float, Double, "fpext float ", " to double")
 327
 328   void
 329   LLVMGeneratorVisitor::castBoolToInteger(const CastExp & node)
 330   {
 331     IntegerType * to = reinterpret_cast<IntegerType *>(node.type);
 332
 333     if (to->size == 1)
 334     {
 335       out_ << "add i1 0, ";
 336       node.exp->accept(*this);
 337     }
 338     else
 339     {
 340       out_ << "zext i1 ";
 341       node.exp->accept(*this);
 342       out_ << " to ";
 343       to->accept(*this);
 344     }
 345   }
 346
 347   void
 348   LLVMGeneratorVisitor::castIntegerToInteger(const CastExp & node)
 349   {
 350     IntegerType * from = reinterpret_cast<IntegerType *>(node.exp->type);
 351     IntegerType * to   = reinterpret_cast<IntegerType *>(node.type);
 352
 353     if (from->size == to->size)
 354     {
 355       out_ << "add i" << to->size << " 0, ";
 356       node.exp->accept(*this);
 357       return;
 358     }
 359
 360     if (from->size > to->size)
 361       out_ << "trunc";
 362     else if (from->isSigned)
 363       out_ << "sext";
 364     else
 365       out_ << "zext";
 366     out_ << " i" << from->size << " ";
 367     node.exp->accept(*this);
 368     out_ << " to i" << to->size;
 369   }
 370
 371 #define INTEGER_TO_FLOAT(Float, Str)                                    \
 372   void                                                                  \
 373   LLVMGeneratorVisitor::castIntegerTo##Float(const CastExp & node)      \
 374   {                                                                     \
 375     IntegerType * from =                                                \
 376       reinterpret_cast<IntegerType *>(node.exp->type);                  \
 377                                                                         \
 378     out_ << (from->isSigned ? "sitofp " : "uitofp ");                   \
 379     from->accept(*this);                                                \
 380     node.exp->accept(*this);                                            \
 381     out_ << " to " Str;                                                 \
 382   }
 383
 384   INTEGER_TO_FLOAT(Float, "float")
 385   INTEGER_TO_FLOAT(Double, "double")
 386
 387   void
 388   LLVMGeneratorVisitor::castIntegerToBool(const ast::CastExp & node)
 389   {
 390     out_ << "icmp ne ";
 391     node.exp->type->accept(*this);
 392     out_ << "0, ";
 393     node.exp->accept(*this);
 394   }
 395
 396 #define FLOAT_TO_BOOL(Type, Str)                                        \
 397   void                                                                  \
 398   LLVMGeneratorVisitor::cast##Type##ToBool(const ast::CastExp & node)   \
 399   {                                                                     \
 400     /** @todo throw a warning */                                        \
 401     assert_msg(false, "casting float to bool is a non sense.");         \
 402   }
 403
 404   FLOAT_TO_BOOL(Float, "float")
 405   FLOAT_TO_BOOL(Double, "double")
 406 }