forked from OSchip/llvm-project
132 lines
3.4 KiB
C++
132 lines
3.4 KiB
C++
//==-- loop_proto_to_cxx.cpp - Protobuf-C++ conversion ---------------------==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Implements functions for converting between protobufs and C++. Differs from
|
|
// proto_to_cxx.cpp by wrapping all the generated C++ code in a single for
|
|
// loop. Also coutputs a different function signature that includes a
|
|
// size_t parameter for the loop to use. The C++ code generated is meant to
|
|
// stress the LLVM loop vectorizer.
|
|
//
|
|
// Still a work in progress.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "cxx_loop_proto.pb.h"
|
|
#include "proto_to_cxx.h"
|
|
|
|
// The following is needed to convert protos in human-readable form
|
|
#include <google/protobuf/text_format.h>
|
|
|
|
#include <ostream>
|
|
#include <sstream>
|
|
|
|
namespace clang_fuzzer {
|
|
|
|
// Forward decls.
|
|
std::ostream &operator<<(std::ostream &os, const BinaryOp &x);
|
|
std::ostream &operator<<(std::ostream &os, const StatementSeq &x);
|
|
|
|
// Proto to C++.
|
|
std::ostream &operator<<(std::ostream &os, const Const &x) {
|
|
return os << "(" << x.val() << ")";
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const VarRef &x) {
|
|
switch (x.arr()) {
|
|
case VarRef::ARR_A:
|
|
return os << "a[i]";
|
|
case VarRef::ARR_B:
|
|
return os << "b[i]";
|
|
case VarRef::ARR_C:
|
|
return os << "c[i]";
|
|
}
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const Rvalue &x) {
|
|
if (x.has_cons())
|
|
return os << x.cons();
|
|
if (x.has_binop())
|
|
return os << x.binop();
|
|
if (x.has_varref())
|
|
return os << x.varref();
|
|
return os << "1";
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const BinaryOp &x) {
|
|
os << "(" << x.left();
|
|
switch (x.op()) {
|
|
case BinaryOp::PLUS:
|
|
os << "+";
|
|
break;
|
|
case BinaryOp::MINUS:
|
|
os << "-";
|
|
break;
|
|
case BinaryOp::MUL:
|
|
os << "*";
|
|
break;
|
|
case BinaryOp::XOR:
|
|
os << "^";
|
|
break;
|
|
case BinaryOp::AND:
|
|
os << "&";
|
|
break;
|
|
case BinaryOp::OR:
|
|
os << "|";
|
|
break;
|
|
case BinaryOp::EQ:
|
|
os << "==";
|
|
break;
|
|
case BinaryOp::NE:
|
|
os << "!=";
|
|
break;
|
|
case BinaryOp::LE:
|
|
os << "<=";
|
|
break;
|
|
case BinaryOp::GE:
|
|
os << ">=";
|
|
break;
|
|
case BinaryOp::LT:
|
|
os << "<";
|
|
break;
|
|
case BinaryOp::GT:
|
|
os << ">";
|
|
break;
|
|
}
|
|
return os << x.right() << ")";
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const AssignmentStatement &x) {
|
|
return os << x.varref() << "=" << x.rvalue() << ";\n";
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const Statement &x) {
|
|
return os << x.assignment();
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const StatementSeq &x) {
|
|
for (auto &st : x.statements())
|
|
os << st;
|
|
return os;
|
|
}
|
|
std::ostream &operator<<(std::ostream &os, const LoopFunction &x) {
|
|
return os << "void foo(int *a, int *b, int *__restrict__ c, size_t s) {\n"
|
|
<< "for (int i=0; i<s; i++){\n"
|
|
<< x.statements() << "}\n}\n";
|
|
}
|
|
|
|
// ---------------------------------
|
|
|
|
std::string LoopFunctionToString(const LoopFunction &input) {
|
|
std::ostringstream os;
|
|
os << input;
|
|
return os.str();
|
|
}
|
|
std::string LoopProtoToCxx(const uint8_t *data, size_t size) {
|
|
LoopFunction message;
|
|
if (!message.ParsePartialFromArray(data, size))
|
|
return "#error invalid proto\n";
|
|
return LoopFunctionToString(message);
|
|
}
|
|
|
|
} // namespace clang_fuzzer
|