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, Method)              \
  21     do {                                                        \
  22       castTableKey_t key = std::make_pair(Type1::nodeTypeId(),  \
  23                                           Type2::nodeTypeId()); \
  24       assert_msg(!castTable_.count(key),                        \
  25                  "the same key has been insterted two times");  \
  26       castTable_[key] = &LLVMGeneratorVisitor::Method;          \
  27     } while (0)
  28
  29     ADD_CAST_TABLE_ENTRY(BoolType, BoolType, castBoolToBool);
  30     ADD_CAST_TABLE_ENTRY(BoolType, IntegerType, castBoolToInteger);
  31     ADD_CAST_TABLE_ENTRY(BoolType, FloatType, castBoolToFloat);
  32     ADD_CAST_TABLE_ENTRY(BoolType, DoubleType, castBoolToDouble);
  33     ADD_CAST_TABLE_ENTRY(IntegerType, IntegerType, castIntegerToInteger);
  34     ADD_CAST_TABLE_ENTRY(IntegerType, FloatType, castIntegerToFloat);
  35     ADD_CAST_TABLE_ENTRY(IntegerType, DoubleType, castIntegerToDouble);
  36     ADD_CAST_TABLE_ENTRY(FloatType, DoubleType, castFloatToDouble);
  37     ADD_CAST_TABLE_ENTRY(DoubleType, BoolType, castDoubleToBool);
  38   }
  39
  40   LLVMGeneratorVisitor::~LLVMGeneratorVisitor()
  41   {
  42   }
  43
  44   void
  45   LLVMGeneratorVisitor::visit(const Function & node)
  46   {
  47     out_ << "define void @" << node.name << "() {" << std::endl;
  48     super_t::visit(node);
  49     out_ << "  ret void" << std::endl
  50          << "}" << std::endl;
  51   }
  52
  53   void
  54   LLVMGeneratorVisitor::visit(const VarDecl & node)
  55   {
  56     assert(node.type);
  57
  58     out_ << "  %" << node.name << " = alloca ";
  59     node.type->accept(*this);
  60     out_ << std::endl;
  61   }
  62
  63   void
  64   LLVMGeneratorVisitor::visit(const LoadVar & node)
  65   {
  66     assert(node.type);
  67
  68     out_ << "  %" << node.to << " = load ";
  69     node.type->accept(*this);
  70     out_ << " * %" << node.name << std::endl;
  71   }
  72
  73   void
  74   LLVMGeneratorVisitor::visit(const StoreVar & node)
  75   {
  76     assert(node.value);
  77     assert(node.value->type);
  78
  79     out_ << "  store ";
  80     node.value->type->accept(*this);
  81     node.value->accept(*this);
  82     out_ << ", ";
  83     node.value->type->accept(*this);
  84     out_ << " * %" << node.name << std::endl;
  85   }
  86
  87   void
  88   LLVMGeneratorVisitor::visit(const AssignExp & node)
  89   {
  90     out_ << "  %" << node.dest->name << " = ";
  91     node.value->accept(*this);
  92     out_ << std::endl;
  93   }
  94
  95 #define GEN_BINARY_EXP_EXT(Name, Type, Instr)   \
  96   void                                          \
  97   LLVMGeneratorVisitor::Name(const Type & node) \
  98   {                                             \
  99     out_ << Instr" ";                           \
 100     node.type->accept(*this);                   \
 101     node.left->accept(*this);                   \
 102     out_ << ", ";                               \
 103     node.right->accept(*this);                  \
 104   }
 105
 106 #define GEN_BINARY_EXP(Type, Instr) GEN_BINARY_EXP_EXT(visit, Type, Instr)
 107
 108   GEN_BINARY_EXP(AddExp, "add")
 109   GEN_BINARY_EXP(SubExp, "sub")
 110   GEN_BINARY_EXP(MulExp, "mul")
 111   GEN_BINARY_EXP_EXT(visitUDivExp, DivExp, "udiv")
 112   GEN_BINARY_EXP_EXT(visitSDivExp, DivExp, "sdiv")
 113   GEN_BINARY_EXP_EXT(visitFDivExp, DivExp, "fdiv")
 114   GEN_BINARY_EXP_EXT(visitUModExp, ModExp, "urem")
 115   GEN_BINARY_EXP_EXT(visitSModExp, ModExp, "srem")
 116   GEN_BINARY_EXP_EXT(visitFModExp, ModExp, "frem")
 117
 118   GEN_BINARY_EXP(AndExp, "and")
 119   GEN_BINARY_EXP(OrExp, "or")
 120   GEN_BINARY_EXP(XorExp, "xor")
 121
 122   GEN_BINARY_EXP(ShlExp, "shl")
 123   GEN_BINARY_EXP(AShrExp, "ashr")
 124   GEN_BINARY_EXP(LShrExp, "lshr")
 125
 126   GEN_BINARY_EXP(EqExp, "icmp eq")
 127   GEN_BINARY_EXP(NeqExp, "icmp ne")
 128   GEN_BINARY_EXP(LtExp, "icmp slt")
 129   GEN_BINARY_EXP(LtEqExp, "icmp sle")
 130   GEN_BINARY_EXP(GtExp, "icmp sgt")
 131   GEN_BINARY_EXP(GtEqExp, "icmp sge")
 132
 133 #define GEN_BINARY_BOOL_EXP(Type, Op)                   \
 134   void                                                  \
 135   LLVMGeneratorVisitor::visit(const Type & node)        \
 136   {                                                     \
 137     out_ << Op " i1 ";                                  \
 138     node.left->accept(*this);                           \
 139     out_ << ", ";                                       \
 140     node.right->accept(*this);                          \
 141   }
 142
 143   GEN_BINARY_BOOL_EXP(AndAndExp, "and ")
 144   GEN_BINARY_BOOL_EXP(OrOrExp, "or ")
 145
 146 #define GEN_DIV_MOD_EXP(Name)                                           \
 147   void                                                                  \
 148   LLVMGeneratorVisitor::visit(const Name##Exp & node)                   \
 149   {                                                                     \
 150     if (node.type->nodeType == BoolType::nodeTypeId())                  \
 151       visitU##Name##Exp(node);                                          \
 152     else if (node.type->nodeType == FloatType::nodeTypeId() ||          \
 153              node.type->nodeType == DoubleType::nodeTypeId())           \
 154       visitF##Name##Exp(node);                                          \
 155     else if (node.type->nodeType == IntegerType::nodeTypeId())          \
 156     {                                                                   \
 157       IntegerType * type = reinterpret_cast<IntegerType *>(node.type);  \
 158       type->isSigned ? visitS##Name##Exp(node) : visitU##Name##Exp(node); \
 159     }                                                                   \
 160     else                                                                \
 161       assert(false);                                                    \
 162   }
 163
 164   GEN_DIV_MOD_EXP(Div)
 165   GEN_DIV_MOD_EXP(Mod)
 166
 167   // void
 168   // LLVMGeneratorVisitor::visit(const EqExp & node)
 169   // {
 170
 171   // }
 172
 173   void
 174   LLVMGeneratorVisitor::visit(const IdExp & node)
 175   {
 176     out_ << "%" << node.name;
 177   }
 178
 179   void
 180   LLVMGeneratorVisitor::visit(const TmpResultExp & node)
 181   {
 182     out_ << "%" << node.name;
 183   }
 184
 185   void
 186   LLVMGeneratorVisitor::visit(const NumberExp & node)
 187   {
 188     if (node.type->nodeType == FloatType::nodeTypeId())
 189       out_ << std::setprecision(1000) << (float)node.number;
 190     else
 191       out_ << std::setprecision(1000) << node.number;
 192   }
 193
 194   void
 195   LLVMGeneratorVisitor::visit(const Label & node)
 196   {
 197     out_ << "  br label %" << node.name << " ; dummy branch to start a block" << std::endl
 198          << node.name << ":" << std::endl;
 199   }
 200
 201   void
 202   LLVMGeneratorVisitor::visit(const Goto & node)
 203   {
 204     out_ << "  br label %" << node.label << std::endl;
 205   }
 206
 207   void
 208   LLVMGeneratorVisitor::visit(const If & node)
 209   {
 210     assert(node.ifTrue->nodeType == Label::nodeTypeId());
 211     assert(node.ifFalse->nodeType == Label::nodeTypeId());
 212
 213     Label * trueLabel = reinterpret_cast<Label *>(node.ifTrue);
 214     Label * falseLabel = reinterpret_cast<Label *>(node.ifFalse);
 215
 216     out_ << "  br i1 ";
 217     node.cond->accept(*this);
 218     out_ << ", label %" << trueLabel->name << ", label %"
 219          << falseLabel->name << std::endl;
 220   }
 221
 222   void
 223   LLVMGeneratorVisitor::visit(const Type & /*node*/)
 224   {
 225     //assert_msg(false, "we should never reach this code");
 226   }
 227
 228   void
 229   LLVMGeneratorVisitor::visit(const NumberType & /*node*/)
 230   {
 231     assert_msg(false, "we should never reach this code");
 232   }
 233
 234   void
 235   LLVMGeneratorVisitor::visit(const BoolType & /*node*/)
 236   {
 237     out_ << " i1 ";
 238   }
 239
 240   void
 241   LLVMGeneratorVisitor::visit(const IntegerType & node)
 242   {
 243     out_ << " i" << node.size << " ";
 244   }
 245
 246   void
 247   LLVMGeneratorVisitor::visit(const FloatType & /*node*/)
 248   {
 249     out_ << " float ";
 250   }
 251
 252   void
 253   LLVMGeneratorVisitor::visit(const DoubleType & /*node*/)
 254   {
 255     out_ << " double ";
 256   }
 257
 258   void
 259   LLVMGeneratorVisitor::visit(const CastExp & node)
 260   {
 261     Type * from = node.exp->type;
 262     Type * to = node.type;
 263
 264     assert(from);
 265     assert(to);
 266     castTableKey_t key = std::make_pair(from->nodeType, to->nodeType);
 267     assert(castTable_.count(key) > 0);
 268     (this->*castTable_[key])(node);
 269   }
 270
 271   void
 272   LLVMGeneratorVisitor::castBoolToBool(const CastExp & node)
 273   {
 274     out_ << "add i1 0, ";
 275     node.exp->accept(*this);
 276     return;
 277   }
 278
 279 #define SIMPLE_NUMBER_CAST(Type1, Type2, CastInstr, DestType)           \
 280   void                                                                  \
 281   LLVMGeneratorVisitor::cast##Type1##To##Type2(const CastExp & node)    \
 282   {                                                                     \
 283     out_ << CastInstr;                                                  \
 284     node.exp->accept(*this);                                            \
 285     out_ << DestType;                                                   \
 286     return;                                                             \
 287   }
 288
 289   SIMPLE_NUMBER_CAST(Bool, Float, "uitofp i1 ", " to float")
 290   SIMPLE_NUMBER_CAST(Bool, Double, "uitofp i1 ", " to double")
 291   SIMPLE_NUMBER_CAST(Float, Double, "fpext float ", " to double")
 292
 293   void
 294   LLVMGeneratorVisitor::castBoolToInteger(const CastExp & node)
 295   {
 296     IntegerType * to = reinterpret_cast<IntegerType *>(node.type);
 297
 298     if (to->size == 1)
 299     {
 300       out_ << "add i1 0, ";
 301       node.exp->accept(*this);
 302     }
 303     else
 304     {
 305       out_ << "zext i1 ";
 306       node.exp->accept(*this);
 307       out_ << " to ";
 308       to->accept(*this);
 309     }
 310   }
 311
 312   void
 313   LLVMGeneratorVisitor::castIntegerToInteger(const CastExp & node)
 314   {
 315     IntegerType * from = reinterpret_cast<IntegerType *>(node.exp->type);
 316     IntegerType * to   = reinterpret_cast<IntegerType *>(node.type);
 317
 318     if (from->size == to->size)
 319     {
 320       out_ << "add i" << to->size << " 0, ";
 321       node.exp->accept(*this);
 322       return;
 323     }
 324
 325     if (from->size > to->size)
 326       out_ << "trunc";
 327     else if (from->isSigned)
 328       out_ << "sext";
 329     else
 330       out_ << "zext";
 331     out_ << " i" << from->size << " ";
 332     node.exp->accept(*this);
 333     out_ << " to i" << to->size;
 334   }
 335
 336 #define INTEGER_TO_FLOAT(Float, Str)                                    \
 337   void                                                                  \
 338   LLVMGeneratorVisitor::castIntegerTo##Float(const CastExp & node)      \
 339   {                                                                     \
 340     IntegerType * from =                                                \
 341       reinterpret_cast<IntegerType *>(node.exp->type);                  \
 342                                                                         \
 343     out_ << (from->isSigned ? "sitofp " : "uitofp ");                   \
 344     from->accept(*this);                                                \
 345     node.exp->accept(*this);                                            \
 346     out_ << " to " Str;                                                 \
 347   }
 348
 349   INTEGER_TO_FLOAT(Float, "float")
 350   INTEGER_TO_FLOAT(Double, "double")
 351 }