Commit 04aff395 authored by Leonard Chan's avatar Leonard Chan
Browse files

Revert "Reland "[clang-repl] Re-implement clang-interpreter as a test case."" 

This reverts commit 1dba6b37.

Reverting because the ClangReplInterpreterExceptionTests test fails on
our builders with this patch.
parent 8e3b9f45

clang/docs/ClangFormattedStatus.rst

+5 −0
Original line number Diff line number Diff line
@@ -59,6 +59,11 @@ tree in terms of conformance to :doc:`ClangFormat` as of: October 02, 2021 15:06 
     - `1`

     - `0`

     - :good:`100%`

   * - clang/examples/clang-interpreter

     - `1`

     - `0`

     - `1`

     - :none:`0%`

   * - clang/examples/PrintFunctionNames

     - `1`

     - `0`

clang/examples/CMakeLists.txt

+1 −0
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ if(NOT CLANG_BUILD_EXAMPLES) 
  set(EXCLUDE_FROM_ALL ON)

endif()



add_subdirectory(clang-interpreter)

add_subdirectory(PrintFunctionNames)

add_subdirectory(AnnotateFunctions)

add_subdirectory(Attribute)

clang/examples/clang-interpreter/CMakeLists.txt

0 → 100644
+93 −0
Original line number Diff line number Diff line 
set(LLVM_LINK_COMPONENTS

  Core

  ExecutionEngine

  MC

  MCJIT

  Object

  OrcJit

  Option

  RuntimeDyld

  Support

  native

  )



add_clang_executable(clang-interpreter

  main.cpp

  )



add_dependencies(clang-interpreter

  clang-resource-headers

  )



clang_target_link_libraries(clang-interpreter

  PRIVATE

  clangBasic

  clangCodeGen

  clangDriver

  clangFrontend

  clangSerialization

  )



export_executable_symbols(clang-interpreter)



if (MSVC)

  # Is this a CMake bug that even with export_executable_symbols, Windows

  # needs to explictly export the type_info vtable

  set_property(TARGET clang-interpreter

               APPEND_STRING PROPERTY LINK_FLAGS " /EXPORT:??_7type_info@@6B@")

endif()



function(clang_enable_exceptions TARGET)

  # Really have to jump through hoops to enable exception handling independent

  # of how LLVM is being built.

  if (NOT LLVM_REQUIRES_EH AND NOT LLVM_REQUIRES_RTTI)

    if (MSVC)

      # /EHs to allow throwing from extern "C"

      set(excptnExceptions_ON "/D _HAS_EXCEPTIONS=1 /EHs /wd4714")

      set(excptnExceptions_OFF "/D _HAS_EXCEPTIONS=0 /EHs-c-")

      set(excptnRTTI_ON "/GR")

      set(excptnRTTI_OFF "/GR-")

      set(excptnEHRTTIRegEx "(/EHs(-c-?)|_HAS_EXCEPTIONS=(0|1))")

    else()

      set(excptnExceptions_ON "-fexceptions")

      set(excptnExceptions_OFF "-fno-exceptions")

      set(excptnRTTI_ON "-frtti")

      set(excptnRTTI_OFF "-fno-rtti")

      set(excptnEHRTTIRegEx "-f(exceptions|no-exceptions)")

    endif()

    if (LLVM_REQUIRES_EH)

      set(excptnExceptions_DFLT ${excptnExceptions_ON})

    else()

      set(excptnExceptions_DFLT ${excptnExceptions_OFF})

    endif()

    if (LLVM_REQUIRES_RTTI)

      set(excptnRTTI_DFLT ${excptnRTTI_ON})

    else()

      set(excptnRTTI_DFLT ${excptnRTTI_OFF})

    endif()



    # Strip the exception & rtti flags from the target

    get_property(addedFlags TARGET ${TARGET} PROPERTY COMPILE_FLAGS)

    string(REGEX REPLACE ${excptnEHRTTIRegEx} "" editedFlags "${addedFlags}")

    string(REPLACE ${excptnRTTI_OFF} "" editedFlags "${editedFlags}")

    set_property(TARGET ${TARGET} PROPERTY COMPILE_FLAGS "${editedFlags}")



    get_property(addedFlags TARGET ${TARGET} PROPERTY COMPILE_DEFINITIONS)

    string(REGEX REPLACE ${excptnEHRTTIRegEx} "" editedFlags "${addedFlags}")

    string(REPLACE ${excptnRTTI_OFF} "" editedFlags "${editedFlags}")

    set_property(TARGET ${TARGET} PROPERTY COMPILE_DEFINITIONS "${editedFlags}")



    # Re-add the exception & rtti flags from LLVM

    set_property(SOURCE main.cpp APPEND_STRING PROPERTY COMPILE_FLAGS

                   " ${excptnExceptions_DFLT} ${excptnRTTI_DFLT} ")

    set_property(SOURCE Manager.cpp APPEND_STRING PROPERTY COMPILE_FLAGS

                   " ${excptnExceptions_DFLT} ${excptnRTTI_DFLT} ")



    # Invoke with exceptions & rtti

    set_property(SOURCE Invoke.cpp APPEND_STRING PROPERTY COMPILE_FLAGS

                   " ${excptnExceptions_ON} ${excptnRTTI_ON} ")



  endif()

endfunction(clang_enable_exceptions)



clang_enable_exceptions(clang-interpreter)

clang/examples/clang-interpreter/README.txt

0 → 100644
+20 −0
Original line number Diff line number Diff line 
This is an example of Clang based interpreter, for executing standalone C/C++

programs.



It demonstrates the following features:

 1. Parsing standard compiler command line arguments using the Driver library.



 2. Constructing a Clang compiler instance, using the appropriate arguments

    derived in step #1.



 3. Invoking the Clang compiler to lex, parse, syntax check, and then generate

    LLVM code.



 4. Use the LLVM JIT functionality to execute the final module.



 5. Intercepting a Win64 library call to allow throwing and catching exceptions

    in and from the JIT.



The implementation has many limitations and is not designed to be a full fledged

interpreter. It is designed to demonstrate a simple but functional use of the

Clang compiler libraries.

clang/examples/clang-interpreter/Test.cxx

0 → 100644
+33 −0
Original line number Diff line number Diff line 
//===-- examples/clang-interpreter/Test.cxx - Clang C Interpreter Example -===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//



// Example throwing in and from the JIT (particularly on Win64).

//

// ./bin/clang-interpreter <src>/tools/clang/examples/clang-interpreter/Test.cxx



#include <stdexcept>

#include <stdio.h>



static void ThrowerAnError(const char* Name) {

  throw std::runtime_error(Name);

}



int main(int argc, const char** argv) {

  for (int I = 0; I < argc; ++I)

   printf("arg[%d]='%s'\n", I, argv[I]);



  try {

    ThrowerAnError("In JIT");

  } catch (const std::exception& E) {

    printf("Caught: '%s'\n", E.what());

  } catch (...) {

    printf("Unknown exception\n");

  }

  ThrowerAnError("From JIT");

  return 0;

}