clang/tools/clang-fuzzer/proto-to-llvm/loop_proto_to_llvm.cpp

   1 //==-- loop_proto_to_llvm.cpp - Protobuf-C++ conversion
   2 //---------------------==//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Implements functions for converting between protobufs and LLVM IR.
  11 //
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "loop_proto_to_llvm.h"
  16 #include "cxx_loop_proto.pb.h"
  17 #include "../handle-llvm/input_arrays.h"
  18
  19 // The following is needed to convert protos in human-readable form
  20 #include <google/protobuf/text_format.h>
  21
  22 #include <ostream>
  23 #include <sstream>
  24
  25 namespace clang_fuzzer {
  26
  27 // Forward decls
  28 std::string BinopToString(std::ostream &os, const BinaryOp &x);
  29 std::string StateSeqToString(std::ostream &os, const StatementSeq &x);
  30
  31 // Counter variable to generate new LLVM IR variable names and wrapper function
  32 static std::string get_var() {
  33   static int ctr = 0;
  34   return "%var" + std::to_string(ctr++);
  35 }
  36
  37 static bool inner_loop = false;
  38 class InnerLoop {
  39   public:
  40   InnerLoop() {
  41     inner_loop = true;
  42   }
  43   ~InnerLoop() {
  44     inner_loop = false;
  45   }
  46 };
  47
  48
  49 // Proto to LLVM.
  50
  51 std::string ConstToString(const Const &x) {
  52   return std::to_string(x.val());
  53 }
  54 std::string VarRefToString(std::ostream &os, const VarRef &x) {
  55   std::string which_loop = inner_loop ? "inner" : "outer";
  56   std::string arr;
  57   switch(x.arr()) {
  58   case VarRef::ARR_A:
  59     arr = "%a";
  60     break;
  61   case VarRef::ARR_B:
  62     arr = "%b";
  63     break;
  64   case VarRef::ARR_C:
  65     arr = "%c";
  66     break;
  67   }
  68   std::string ptr_var = get_var();
  69   os << ptr_var << " = getelementptr inbounds i32, i32* " << arr
  70      << ", i64 %" << which_loop << "_ct\n";
  71   return ptr_var;
  72 }
  73 std::string RvalueToString(std::ostream &os, const Rvalue &x) {
  74   if(x.has_cons())
  75     return ConstToString(x.cons());
  76   if(x.has_binop())
  77     return BinopToString(os, x.binop());
  78   if(x.has_varref()) {
  79     std::string var_ref = VarRefToString(os, x.varref());
  80     std::string val_var = get_var();
  81     os << val_var << " = load i32, i32* " << var_ref << "\n";
  82     return val_var;
  83   }
  84   return "1";
  85
  86 }
  87 std::string BinopToString(std::ostream &os, const BinaryOp &x) {
  88   std::string left = RvalueToString(os, x.left());
  89   std::string right = RvalueToString(os, x.right());
  90   std::string op;
  91   switch (x.op()) {
  92   case BinaryOp::PLUS:
  93     op = "add";
  94     break;
  95   case BinaryOp::MINUS:
  96     op = "sub";
  97     break;
  98   case BinaryOp::MUL:
  99     op = "mul";
 100     break;
 101   case BinaryOp::XOR:
 102     op = "xor";
 103     break;
 104   case BinaryOp::AND:
 105     op = "and";
 106     break;
 107   case BinaryOp::OR:
 108     op = "or";
 109     break;
 110   // Support for Boolean operators will be added later
 111   case BinaryOp::EQ:
 112   case BinaryOp::NE:
 113   case BinaryOp::LE:
 114   case BinaryOp::GE:
 115   case BinaryOp::LT:
 116   case BinaryOp::GT:
 117     op = "add";
 118     break;
 119   }
 120   std::string val_var = get_var();
 121   os << val_var << " = " << op << " i32 " << left << ", " << right << "\n";
 122   return val_var;
 123 }
 124 std::ostream &operator<<(std::ostream &os, const AssignmentStatement &x) {
 125   std::string rvalue = RvalueToString(os, x.rvalue());
 126   std::string var_ref = VarRefToString(os, x.varref());
 127   return os << "store i32 " << rvalue << ", i32* " << var_ref << "\n";
 128 }
 129 std::ostream &operator<<(std::ostream &os, const Statement &x) {
 130   return os << x.assignment();
 131 }
 132 std::ostream &operator<<(std::ostream &os, const StatementSeq &x) {
 133   for (auto &st : x.statements()) {
 134     os << st;
 135   }
 136   return os;
 137 }
 138 void NestedLoopToString(std::ostream &os, const LoopFunction &x) {
 139   os << "target triple = \"x86_64-unknown-linux-gnu\"\n"
 140      << "define void @foo(i32* %a, i32* %b, i32* noalias %c, i64 %s) {\n"
 141      << "outer_loop_start:\n"
 142      << "%cmp = icmp sgt i64 %s, 0\n"
 143      << "br i1 %cmp, label %inner_loop_start, label %end\n"
 144      << "outer_loop:\n"
 145      << x.outer_statements()
 146      << "%o_ct_new = add i64 %outer_ct, 1\n"
 147      << "%jmp_outer = icmp eq i64 %o_ct_new, %s\n"
 148      << "br i1 %jmp_outer, label %end, label %inner_loop_start\n"
 149      << "inner_loop_start:\n"
 150      << "%outer_ct = phi i64 [%o_ct_new, %outer_loop], [0, %outer_loop_start]\n"
 151      << "br label %inner_loop\n"
 152      << "inner_loop:\n"
 153      << "%inner_ct = phi i64 [0, %inner_loop_start], [%i_ct_new, %inner_loop]\n";
 154   {
 155     InnerLoop IL;
 156     os << x.inner_statements();
 157   }
 158   os << "%i_ct_new = add i64 %inner_ct, 1\n"
 159      << "%jmp_inner = icmp eq i64 %i_ct_new, %s\n"
 160      << "br i1 %jmp_inner, label %outer_loop, label %inner_loop, !llvm.loop !0\n"
 161      << "end:\n"
 162      << "ret void\n"
 163      << "}\n"
 164      << "!0 = distinct !{!0, !1, !2}\n"
 165      << "!1 = !{!\"llvm.loop.vectorize.enable\", i1 true}\n"
 166      << "!2 = !{!\"llvm.loop.vectorize.width\", i32 " << kArraySize << "}\n";
 167 }
 168 void SingleLoopToString(std::ostream &os, const LoopFunction &x) {
 169   os << "target triple = \"x86_64-unknown-linux-gnu\"\n"
 170      << "define void @foo(i32* %a, i32* %b, i32* noalias %c, i64 %s) {\n"
 171      << "%cmp = icmp sgt i64 %s, 0\n"
 172      << "br i1 %cmp, label %start, label %end\n"
 173      << "start:\n"
 174      << "br label %loop\n"
 175      << "end:\n"
 176      << "ret void\n"
 177      << "loop:\n"
 178      << "%outer_ct = phi i64 [ %ctnew, %loop ], [ 0, %start ]\n"
 179      << x.outer_statements()
 180      << "%ctnew = add i64 %outer_ct, 1\n"
 181      << "%j = icmp eq i64 %ctnew, %s\n"
 182      << "br i1 %j, label %end, label %loop, !llvm.loop !0\n}\n"
 183      << "!0 = distinct !{!0, !1, !2}\n"
 184      << "!1 = !{!\"llvm.loop.vectorize.enable\", i1 true}\n"
 185      << "!2 = !{!\"llvm.loop.vectorize.width\", i32 " << kArraySize << "}\n";
 186 }
 187 std::ostream &operator<<(std::ostream &os, const LoopFunction &x) {
 188   if (x.has_inner_statements())
 189     NestedLoopToString(os, x);
 190   else
 191     SingleLoopToString(os, x);
 192   return os;
 193 }
 194
 195 // ---------------------------------
 196
 197 std::string LoopFunctionToLLVMString(const LoopFunction &input) {
 198   std::ostringstream os;
 199   os << input;
 200   return os.str();
 201 }
 202 std::string LoopProtoToLLVM(const uint8_t *data, size_t size) {
 203   LoopFunction message;
 204   if (!message.ParsePartialFromArray(data, size))
 205     return "#error invalid proto\n";
 206   return LoopFunctionToLLVMString(message);
 207 }
 208
 209 } // namespace clang_fuzzer