Code Monkey home page Code Monkey logo

accsynt's Introduction

AccSynt

AccSynt is a collection of tools and utilities for building program synthesizers in LLVM.

Building

Build prerequisites:

  • CMake 3.2 or newer
  • Conan
  • A C++ compiler with C++17 support, such as g++ 7 or newer.

The build instructions in this section assume an environment variable $BUILD_ROOT that points to where you want to build LLVM and AccSynt.

LLVM 10

cd $BUILD_ROOT
git clone [email protected]:llvm/llvm-project
cd llvm-project
git checkout llvmorg-10.0.0
mkdir build
cd build
cmake \
  -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_C_COMPILER=$YOUR_CC \
  -DCMAKE_CXX_COMPILER=$YOUR_CXX \
  -DCMAKE_INSTALL_PREFIX=$BUILD_ROOT/llvm-install \
  -DLLVM_ENABLE_RTTI=On \
  -DLLVM_TARGETS_TO_BUILD=X86 \
  -DLLVM_ENABLE_PROJECTS="clang;libcxx;libcxxabi" \
  -DDEFAULT_SYSROOT=$(xcode-select -p)/SDKs/MacOSX.sdk" \
  ../llvm
make -j`nproc`
make install

Note that it's important to build LLVM and AccSynt with the same host compiler or you will run into library incompatibility issues. The host compiler also needs to support C++17 for AccSynt.

AccSynt

cd $BUILD_ROOT
git clone https://github.com/Baltoli/accsynt.git
cd accsynt
mkdir build
cd build
cmake \
      -DCMAKE_BUILD_TYPE=Debug \
      -DCMAKE_C_COMPILER=$YOUR_CC \
      -DCMAKE_CXX_COMPILER=$YOUR_CXX \
      -DLLVM_DIR=$BUILD_ROOT/llvm-install/lib/cmake/llvm \
      ../src
make -j`nproc`
make install

The following conan remotes might be needed in order to build the project:

https://api.bintray.com/conan/baltoli/value_ptr
https://api.bintray.com/conan/bincrafters/public-conan

accsynt's People

Contributors

baltoli avatar dependabot[bot] avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar

accsynt's Issues

Pointer parameter type

Fixed size arrays are useful, but lots of interfaces that I've seen use pointers + a size parameter. Adding these to the type system will be a big jump in terms of what we can synthesize.

Unified return interface

This is quite a complex improvement - at the moment, I implement function returns in the function callable interface by using an actual return value. This approach isn't scalable to more general functions that might mutate a parameter in order to "return" a complex type.

The FunctionCallable interface and type system needs to be modified to support out parameters.

Clarify index bounds

In the synthesis metadata, are index bounds the last permissible value or one past the end?

Unified namespace

All the code in the project should probably live in the same namespace rather than in different ones.

Broken codegen

The new non-indexed loops seem to break code generation somehow - have a look at the IR they're generating. I think it's likely that something obvious is broken and instructions are being generated in some kind of invalid way.

Generating integer constants

Not every computation is a function of parameters given to the interface - we should be able to synthesise operations where one of the parameters is a constant.

Reference functions accept vectors

They need to actually accept raw pointers - vectors aren't what get passed around. I think a useful proxy for this is to make sure that any reference functions get declared as extern "C".

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.