├── TODO
├── .clang-format
├── .gitignore
├── stop.jpg
├── inputs
    ├── with-headers1
    │   ├── header_nested.h
    │   ├── header.h
    │   └── source.cpp
    ├── fptr.c
    ├── pass-nullptr.c
    ├── ptrtoptrparam.c
    ├── globals.c
    ├── iflhsptr.c
    ├── nullptr.cpp
    ├── funcwithattr.c
    ├── cfunc_with_if.c
    ├── basic-kernel-call.cu
    ├── xcudacxx11-repro.cpp
    ├── cstr-for-replacement.cpp
    ├── div0.c
    ├── funcallsample.cpp
    ├── nestedloops.c
    ├── threadidx.c
    ├── c_if_and_for.c
    ├── structinit.c
    ├── twodoublefoo.c
    ├── union.c
    ├── fact.c
    ├── README.rst
    ├── template-insts.cpp
    ├── vectortype.ll
    ├── simpleswitch.c
    ├── diamond-cfg.ll
    ├── namesp.cpp
    ├── types.c
    ├── assert.cc
    ├── using_builtins.c
    ├── loopy-cfg.ll
    ├── cuda_support_header.h
    ├── kernel-signatures.c
    ├── threadidx.ll
    ├── ctor-initializer-list.cpp
    ├── globals.ll
    ├── twodoublefoo.ll
    ├── typeuse.cpp
    ├── fact.ll
    ├── simpleswitch.ll
    ├── bigfunc.c
    └── types.ll
├── reformat.sh
├── using_clang_toolchain
    ├── README.rst
    ├── simple.cpp
    ├── warn_in_macro.cpp
    ├── cxx11-range-sample.cpp
    ├── exceptions1.cpp
    ├── memmain.c
    ├── memcaller.c
    └── Makefile
├── .vimrc
├── test
    ├── test_hello_pass_plugin.py
    ├── all_tests.py
    ├── test_clang_check.py
    ├── test_simple_module_pass.py
    ├── test_rewriter_sample.py
    ├── test_tooling_sample.py
    ├── test_simple_bb_pass.py
    ├── test_bb_toposort_sccs.py
    └── tools.py
├── src_clang
    ├── experimental
    │   ├── showattrs.py
    │   ├── callexpr.py
    │   ├── show-mangle.py
    │   ├── kernel-sigs.py
    │   ├── toplevel_decls.cpp
    │   ├── apply_replacements_with_rewriter.cpp
    │   ├── RemoveCStrCalls.cpp
    │   └── try_matcher.cpp
    ├── plugin_print_funcnames.cpp
    ├── matchers_rewriter.cpp
    ├── tooling_sample.cpp
    ├── rewritersample.cpp
    └── ClangCheck.cpp
├── tools
    ├── sample-js.js
    ├── template.html
    ├── show-cfg.py
    ├── gen_c_straightline.py
    └── htmlize-ast-dump.py
├── LICENSE
├── src_llvm
    ├── access_debug_metadata.cpp
    ├── hello_pass.cpp
    ├── experimental
    │   ├── loop_info.cpp
    │   └── build_llvm_ir.cpp
    ├── simple_module_pass.cpp
    ├── simple_bb_pass.cpp
    ├── analyze_geps.cpp
    ├── replace_threadidx_with_call.cpp
    └── bb_toposort_sccs.cpp
├── README.rst
└── Makefile


/TODO:
--------------------------------------------------------------------------------
1 | * 
2 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
1 | BasedOnStyle: LLVM
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | build/
2 | *.pyc
3 | *.dot
4 | 
5 | 


--------------------------------------------------------------------------------
/stop.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eliben/llvm-clang-samples/HEAD/stop.jpg


--------------------------------------------------------------------------------
/inputs/with-headers1/header_nested.h:
--------------------------------------------------------------------------------
1 | int int_from_nested;
2 | float float_from_nested;
3 | 


--------------------------------------------------------------------------------
/reformat.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | set -eu
3 | 
4 | pss --cpp -f src_llvm src_clang | xargs clang-format -style=LLVM -i
5 | 


--------------------------------------------------------------------------------
/inputs/fptr.c:
--------------------------------------------------------------------------------
1 | extern void (*v)(void*);
2 | 
3 | void foo(int* x, int *y, void (*f)(int*)) {
4 |   v = f;
5 | }
6 | 
7 | 
8 | 


--------------------------------------------------------------------------------
/inputs/with-headers1/header.h:
--------------------------------------------------------------------------------
1 | int int_from_header;
2 | 
3 | #include "header_nested.h"
4 | 
5 | double double_from_header;
6 | 


--------------------------------------------------------------------------------
/inputs/with-headers1/source.cpp:
--------------------------------------------------------------------------------
1 | #include "header.h"
2 | 
3 | struct {
4 |   int a;
5 |   int b;
6 | } struct_from_source;
7 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/README.rst:
--------------------------------------------------------------------------------
1 | These are samples of using the Clang+LLVM toolchain for building actual
2 | executables.
3 | 


--------------------------------------------------------------------------------
/inputs/pass-nullptr.c:
--------------------------------------------------------------------------------
1 | int foo(char* a, char* b);
2 | 
3 | 
4 | int bar() {
5 |   char c;
6 |   foo(&c, 0);
7 |   return c;
8 | }
9 | 


--------------------------------------------------------------------------------
/inputs/ptrtoptrparam.c:
--------------------------------------------------------------------------------
1 | char foo(char** ppc, char a, char b) {
2 |   char* pc = *ppc;
3 |   char c = pc[1];
4 |   return c;
5 | }
6 | 


--------------------------------------------------------------------------------
/inputs/globals.c:
--------------------------------------------------------------------------------
1 | int gint;
2 | float gfloat;
3 | 
4 | float** gppfloat;
5 | 
6 | float foo() {
7 |   return gfloat + **gppfloat;
8 | }
9 | 


--------------------------------------------------------------------------------
/inputs/iflhsptr.c:
--------------------------------------------------------------------------------
1 | int foo(int* p, int v) {
2 |   if (p == 0) {
3 |     return v + 1;
4 |   } else {
5 |     return v - 1;
6 |   }
7 | }
8 | 
9 | 


--------------------------------------------------------------------------------
/inputs/nullptr.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdlib.h>
 2 | 
 3 | int *foo() {
 4 | #ifdef FOO
 5 |   return 0;
 6 | #else
 7 |   return NULL;
 8 | #endif
 9 | }
10 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/simple.cpp:
--------------------------------------------------------------------------------
1 | #include <iostream>
2 | 
3 | int main(int argc, char **argv) {
4 |   std::cout << "Hello world\n";
5 |   return 0;
6 | }
7 | 


--------------------------------------------------------------------------------
/inputs/funcwithattr.c:
--------------------------------------------------------------------------------
1 | __attribute__((device)) void foodev() {
2 | }
3 | 
4 | __attribute__((global)) void barglob() {
5 | }
6 | 
7 | void baznone() {
8 | }
9 | 


--------------------------------------------------------------------------------
/inputs/cfunc_with_if.c:
--------------------------------------------------------------------------------
1 | void foo(int* a, int *b) {
2 |   if (a[0] > 1) {
3 |     b[0] = 2;
4 |   }
5 | }
6 | 
7 | void bar(float x, float y); // just a declaration
8 | 


--------------------------------------------------------------------------------
/inputs/basic-kernel-call.cu:
--------------------------------------------------------------------------------
1 | __attribute__((global)) void kernel(int* in, int* out) {}
2 | 
3 | 
4 | void host_func_foobar(int* inbuf, int* outbuf) {
5 |   kernel<<<1, 32>>>(inbuf, outbuf);
6 | }
7 | 


--------------------------------------------------------------------------------
/inputs/xcudacxx11-repro.cpp:
--------------------------------------------------------------------------------
1 | template <typename T> struct K1 { T member; };
2 | 
3 | template <typename T> struct K2 { T member; };
4 | 
5 | template <typename T> struct K3 { T member; };
6 | 
7 | K3<K2<K1<int>>> var;
8 | 


--------------------------------------------------------------------------------
/inputs/cstr-for-replacement.cpp:
--------------------------------------------------------------------------------
1 | #include <string>
2 | 
3 | int foo(std::string s);
4 | 
5 | int bar(std::string joe) {
6 |   // This c_str() call should be replaced by remov-cstr-calls
7 |   return foo(joe.c_str());
8 | }
9 | 


--------------------------------------------------------------------------------
/inputs/div0.c:
--------------------------------------------------------------------------------
 1 | #define DODIV(a, b) ((a) / (b))
 2 | 
 3 | int test(int z) {
 4 |   if (z == 0) {
 5 | #ifdef FOO
 6 |     return DODIV(1, z);
 7 | #else
 8 |     return 1 - z;
 9 | #endif
10 |   }
11 |   return 1 + z;
12 | }
13 | 


--------------------------------------------------------------------------------
/inputs/funcallsample.cpp:
--------------------------------------------------------------------------------
 1 | bool foo() { return true; }
 2 | 
 3 | void bar() {
 4 |   foo();
 5 |   for (int i = 0; i < 10; ++i)
 6 |     foo();
 7 | }
 8 | 
 9 | int main() {
10 |   bar();
11 |   if (foo())
12 |     bar();
13 | }
14 | 


--------------------------------------------------------------------------------
/inputs/nestedloops.c:
--------------------------------------------------------------------------------
 1 | extern int bar(int);
 2 | 
 3 | void foobar(int* x, int* y) {
 4 |   for (int i = x[0]; i < x[1]; ++i) {
 5 |     for (int j = x[2]; j < x[3]; ++j) {
 6 |       y[i - j] = x[i + j] - bar(x[j]);
 7 |     }
 8 |   }
 9 | }
10 | 
11 | 


--------------------------------------------------------------------------------
/inputs/threadidx.c:
--------------------------------------------------------------------------------
 1 | typedef struct {
 2 |   unsigned x, y, z;
 3 | } uint3;
 4 | 
 5 | const extern uint3 threadIdx;
 6 | 
 7 | 
 8 | int foo(int a, int b) {
 9 |   if (threadIdx.y > 5) {
10 |     return a;
11 |   } else {
12 |     return b;
13 |   }
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/inputs/c_if_and_for.c:
--------------------------------------------------------------------------------
 1 | void foo(int* a, int *b) {
 2 |   if (a[0] > 1) {
 3 |     b[0] = 2;
 4 |   }
 5 | }
 6 | 
 7 | void bar(float x, float y); // just a declaration
 8 | 
 9 | void bang(int* a, int v) {
10 |     for (int i = 0; i < v; ++i) {
11 |         a[i] -= i;
12 |     }
13 | }


--------------------------------------------------------------------------------
/inputs/structinit.c:
--------------------------------------------------------------------------------
 1 | typedef struct {
 2 |   unsigned x, y, z;
 3 | } uint3;
 4 | 
 5 | volatile extern uint3 vglob;
 6 | 
 7 | unsigned foo(unsigned a, unsigned b, unsigned c) {
 8 |   uint3 temp = {a, b, c};
 9 |   vglob = temp;
10 |   return temp.x + temp.y + temp.z;
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/inputs/twodoublefoo.c:
--------------------------------------------------------------------------------
 1 | double foo(double a, double b) {
 2 |   return 2 * a + b;
 3 | }
 4 | 
 5 | __attribute__((noinline)) static double internal(double a, double b) {
 6 |   return a * b;
 7 | }
 8 | 
 9 | double bar(double a, double b) {
10 |   return internal(a, b) * 10;
11 | }
12 | 


--------------------------------------------------------------------------------
/inputs/union.c:
--------------------------------------------------------------------------------
 1 | typedef union {
 2 |   double dnum;
 3 |   int inum;
 4 |   float* fptr;
 5 | } my_union;
 6 | 
 7 | 
 8 | /*int foo(void* p) {*/
 9 |   /*my_union mp = *((my_union*)p);*/
10 |   /*return mp.inum;*/
11 | /*}*/
12 | 
13 | int bar(my_union* mu) {
14 |   return mu[4].inum;
15 | }
16 | 


--------------------------------------------------------------------------------
/.vimrc:
--------------------------------------------------------------------------------
1 | " Force indentation styles for this directory
2 | autocmd FileType python set shiftwidth=4
3 | autocmd FileType python set tabstop=4
4 | autocmd FileType python set softtabstop=4
5 | 
6 | autocmd FileType c set shiftwidth=2
7 | autocmd FileType c set tabstop=2
8 | autocmd FileType c set softtabstop=2
9 | 


--------------------------------------------------------------------------------
/inputs/fact.c:
--------------------------------------------------------------------------------
 1 | unsigned mult(unsigned a, unsigned b) {
 2 |   unsigned s = 0;
 3 |   for (int i = 0; i < a; ++i) {
 4 |     s += b;
 5 |   }
 6 |   return s;
 7 | }
 8 | 
 9 | unsigned fact(unsigned a) {
10 |   if (a <= 1) {
11 |     return 1;
12 |   } else {
13 |     return a * fact(a - 1);
14 |   }
15 | }
16 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/warn_in_macro.cpp:
--------------------------------------------------------------------------------
 1 | #define MYCHECK(a) (0 && 4)
 2 | 
 3 | int main(int argc, char **argv) {
 4 | 
 5 |   // Warning here
 6 |   while (0 && 4) {
 7 |   }
 8 | 
 9 |   // But no warning here, since 4 comes from a macro
10 |   while (MYCHECK(argc)) {
11 |   }
12 | 
13 |   return 0;
14 | }
15 | 


--------------------------------------------------------------------------------
/inputs/README.rst:
--------------------------------------------------------------------------------
 1 | LLVM IR is in .ll files; if an .ll file has a corresponding .c file, then the
 2 | .ll file can be generated by calling clang::
 3 | 
 4 |     clang -cc1 -emit-llvm <file.c>
 5 | 
 6 | For an optimized version, the following can be used::
 7 | 
 8 |     clang -O3 -c -emit-llvm z.c -S -o -
 9 | 
10 | 


--------------------------------------------------------------------------------
/inputs/template-insts.cpp:
--------------------------------------------------------------------------------
 1 | template <typename T, int N> T foo(T a, T b) {
 2 |   T k = a;
 3 |   for (int i = 0; i < N; ++i) {
 4 |     k = k * a + b;
 5 |   }
 6 |   return k;
 7 | }
 8 | 
 9 | int intyfoo(int x, int y) { return foo<int, 6>(x, y); }
10 | 
11 | float floatyfoo(float x, float y) { return foo<float, 128>(x, y); }
12 | 


--------------------------------------------------------------------------------
/inputs/vectortype.ll:
--------------------------------------------------------------------------------
 1 | ; Example of using long vector types with arithmetic.
 2 | ;
 3 | ; llc -O3 inputs/vectortype.ll -o -
 4 | ;
 5 | ; also try with -mattr=avx2 for leveraging AVX2 instructions.
 6 | 
 7 | define <512 x i32> @add_vecs(<512 x i32> %a, <512 x i32> %b) {
 8 |    %1 = add <512 x i32> %a,  %b
 9 |    ret <512 x i32> %1
10 | }
11 | 


--------------------------------------------------------------------------------
/inputs/simpleswitch.c:
--------------------------------------------------------------------------------
 1 | unsigned decide(unsigned char pred, unsigned a[10]) {
 2 |   if (pred > a[2]) {
 3 |     return a[3];
 4 |   }
 5 |   switch (pred) {
 6 |     case 1:
 7 |       return a[0] + a[2];
 8 |     case 2:
 9 |       return a[3] - a[4];
10 |     case 200:
11 |       return a[5] * a[6];
12 |     default:
13 |       break;
14 |   }
15 | 
16 |   return a[9] * a[4];
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/cxx11-range-sample.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | 
 4 | int main(int argc, char **argv) {
 5 |   // Container initialization - shiny!
 6 |   std::vector<int> nums = {1, 2, 3, 4, 5};
 7 | 
 8 |   // auto + for-range loop - shiny^2!
 9 |   for (auto &n : nums) {
10 |     std::cout << n << " ";
11 |   }
12 | 
13 |   std::cout << std::endl;
14 |   return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/inputs/diamond-cfg.ll:
--------------------------------------------------------------------------------
 1 | ; Crafted to have a diamond-like CFG for testing the CFG analysis
 2 | ; samples.
 3 | 
 4 | define i32 @func(i32 %a, i32 %b) #0 {
 5 | AA:
 6 |   %cmp1 = icmp eq i32 %a, %b
 7 |   br i1 %cmp1, label %BB, label %CC
 8 | 
 9 | BB:
10 |   %cmp2 = icmp ult i32 %a, %b
11 |   br i1 %cmp2, label %CC, label %DD
12 | 
13 | CC:
14 |   br label %DD
15 | 
16 | DD:
17 |   ret i32 %a
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/test/test_hello_pass_plugin.py:
--------------------------------------------------------------------------------
 1 | import sys, unittest
 2 | from tools import SamplesTestCase
 3 | 
 4 | OUTPUT_HELLO_FUNCS = '''\
 5 | Hello: mult
 6 | Hello: fact
 7 | '''
 8 | 
 9 | class TestHelloPassPlugin(SamplesTestCase):
10 |     def test_hello_on_fact(self):
11 |         self.assertOptPluginOutput('hello_pass.so', ['-hello-funcs'], 'fact.ll',
12 |             OUTPUT_HELLO_FUNCS)
13 | 
14 | if __name__ == '__main__':
15 |     unittest.main()
16 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/exceptions1.cpp:
--------------------------------------------------------------------------------
 1 | #include <exception>
 2 | #include <iostream>
 3 | #include <stdexcept>
 4 | 
 5 | void foo(int i) {
 6 |   if (i > 2) {
 7 |     throw std::runtime_error("Expected i <= 2");
 8 |   }
 9 | }
10 | 
11 | int main(int argc, char **argv) {
12 |   try {
13 |     foo(argc);
14 |   } catch (std::exception &e) {
15 |     std::cerr << "Got exception: " << e.what() << std::endl;
16 |   }
17 | 
18 |   return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/test/all_tests.py:
--------------------------------------------------------------------------------
 1 | import os, sys, unittest
 2 | 
 3 | if not os.path.isdir('inputs') or not os.path.isdir('build'):
 4 |     print('ERROR: Please execute from the project root directory.')
 5 |     print('.....  And build the samples first.')
 6 |     sys.exit(1)
 7 | else:
 8 |     tests = unittest.TestLoader().discover('test', 'test*.py', 'test')
 9 |     result = unittest.TextTestRunner().run(tests)
10 |     sys.exit(0 if result.wasSuccessful() else 1)
11 | 


--------------------------------------------------------------------------------
/inputs/namesp.cpp:
--------------------------------------------------------------------------------
 1 | namespace Vroom {
 2 | int kwa;
 3 | 
 4 | int foobar(int i) { return i * 2; }
 5 | 
 6 | constexpr double dodo();
 7 | 
 8 | float bar3();
 9 | double foo2();
10 | 
11 | float bolly();
12 | 
13 | struct Joe {
14 |   double bar3();
15 | };
16 | };
17 | 
18 | int bolly();
19 | 
20 | namespace Swing {
21 | constexpr float juju = 2.0;
22 | 
23 | float foobar(float i) { return i * 2; }
24 | 
25 | using ::bolly;
26 | };
27 | 
28 | namespace blagonda {
29 | using Vroom::bolly;
30 | };
31 | 


--------------------------------------------------------------------------------
/test/test_clang_check.py:
--------------------------------------------------------------------------------
 1 | import os, sys, unittest
 2 | from tools import run_exe
 3 | 
 4 | 
 5 | class TestClangCheck(unittest.TestCase):
 6 |     def test_live(self):
 7 |         # basic smoke test
 8 |         exe = os.path.join('build', 'clang-check')
 9 |         input = os.path.join('inputs', 'fact.c')
10 |         rc, stdout = run_exe(exe, ['-ast-print', input, '--'])
11 |         self.assertTrue(stdout.startswith(b'unsigned int'))
12 | 
13 | if __name__ == '__main__':
14 |   unittest.main()
15 | 


--------------------------------------------------------------------------------
/inputs/types.c:
--------------------------------------------------------------------------------
 1 | typedef struct {
 2 |   double d;
 3 |   char c;
 4 |   unsigned i;
 5 |   char ar[10];
 6 | } mystruct;
 7 | 
 8 | void *cpy(void *dest, const void *src, unsigned n);
 9 | 
10 | void structadder(mystruct a, mystruct b, mystruct *out) {
11 |   mystruct ss;
12 |   ss.d = a.d + b.d;
13 |   ss.c = a.c + b.c;
14 |   ss.i = a.i + b.i;
15 |   for (int i = 0; i < b.i; ++i) {
16 |     ss.ar[i] = a.ar[i] + b.ar[i];
17 |   }
18 |   out[13].ar[2] += 1;
19 |   cpy(out, &ss, sizeof(mystruct));
20 | }
21 | 
22 | 


--------------------------------------------------------------------------------
/test/test_simple_module_pass.py:
--------------------------------------------------------------------------------
 1 | import sys, unittest
 2 | from tools import SamplesTestCase
 3 | 
 4 | 
 5 | OUTPUT_FOR_GLOBALS = '''\
 6 | Found global named "gfloat": type = float*
 7 | Found global named "gppfloat": type = float***
 8 | Found global named "gint": type = i32*
 9 | '''
10 | 
11 | PROG = 'simple_module_pass'
12 | 
13 | class TestSimpleModulePass(SamplesTestCase):
14 |     def test_on_globals(self):
15 |         self.assertSampleOutput([PROG], 'globals.ll', OUTPUT_FOR_GLOBALS)
16 | 
17 | if __name__ == '__main__':
18 |   unittest.main()
19 | 


--------------------------------------------------------------------------------
/inputs/assert.cc:
--------------------------------------------------------------------------------
 1 |   extern "C" void __assertfail(
 2 |     const void  *message,
 3 |     const void  *file,
 4 |     unsigned int line,
 5 |     const void  *function,
 6 |     unsigned long       charsize);
 7 | 
 8 |   void __assert_fail(
 9 |     const char  *__assertion,
10 |     const char  *__file,
11 |     unsigned int __line,
12 |     const char  *__function)
13 |   {
14 |     __assertfail(
15 |       (const void *)__assertion,
16 |       (const void *)__file,
17 |                     __line,
18 |       (const void *)__function,
19 |       sizeof(char));
20 |   }
21 | 


--------------------------------------------------------------------------------
/inputs/using_builtins.c:
--------------------------------------------------------------------------------
 1 | // This code uses printf without declaring.
 2 | //
 3 | // This will emit a warning and produce a declaration for the builtin
 4 | // implicitly:
 5 | //
 6 | //   clang -cc1 -emit-llvm inputs/using_builtins.c
 7 | //
 8 | // It will also produce a warning about mismatch in %d format with 'f' argument.
 9 | //
10 | // This (C++ mode) will error, because in C++ such implicit declarations are not
11 | // legal:
12 | //
13 | //   clang -cc1 -x c++ -emit-llvm  inputs/using_builtins.c
14 | //
15 | 
16 | void foo(int i, float f) {
17 |   printf("%d %f\n", f, f);
18 | }
19 | 


--------------------------------------------------------------------------------
/test/test_rewriter_sample.py:
--------------------------------------------------------------------------------
 1 | import os, sys, unittest
 2 | from tools import SamplesTestCase
 3 | 
 4 | OUTPUT = '''\
 5 | // Begin function foo returning void
 6 | void foo(int* a, int *b) {
 7 |   if (a[0] > 1) // the 'if' part
 8 |   {
 9 |     b[0] = 2;
10 |   }
11 | }
12 | // End function foo
13 | 
14 | void bar(float x, float y); // just a declaration
15 | '''
16 | 
17 | PROG = 'rewritersample'
18 | 
19 | class TestRewriterSample(SamplesTestCase):
20 |     def test_live(self):
21 |         self.assertSampleOutput([PROG], 'cfunc_with_if.c', OUTPUT)
22 | 
23 | if __name__ == '__main__':
24 |   unittest.main()
25 | 


--------------------------------------------------------------------------------
/test/test_tooling_sample.py:
--------------------------------------------------------------------------------
 1 | import os, sys, unittest
 2 | from tools import SamplesTestCase
 3 | 
 4 | OUTPUT = '''\
 5 | // Begin function foo returning void
 6 | void foo(int* a, int *b) {
 7 |   if (a[0] > 1) // the 'if' part
 8 |   {
 9 |     b[0] = 2;
10 |   }
11 | }
12 | // End function foo
13 | 
14 | void bar(float x, float y); // just a declaration
15 | '''
16 | 
17 | PROG = 'tooling_sample'
18 | 
19 | class TestToolingSample(SamplesTestCase):
20 |     def test_live(self):
21 |         self.assertClangToolOutput([PROG], 'cfunc_with_if.c', OUTPUT)
22 | 
23 | if __name__ == '__main__':
24 |   unittest.main()
25 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/memmain.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | 
 3 | void* memcpy_caller(void* dst, const void* src, size_t n);
 4 | void* memmove_caller(void* dst, const void* src, size_t n);
 5 | void* memset_caller(void* dst, int c, size_t n);
 6 | 
 7 | int main(int argc, char** argv) {
 8 |   const size_t N = 256;
 9 |   char buf[N];
10 | 
11 |   for (size_t i = 0; i < N; ++i) {
12 |     buf[i] = i;
13 |   }
14 | 
15 |   memmove_caller(&buf[4], &buf[0], 0);
16 |   //memmove_caller(&buf[1], &buf[5], 0);
17 | 
18 |   for (size_t i = 0; i < 30; ++i) {
19 |     printf("0x%x ", buf[i]);
20 |   }
21 |   printf("\n");
22 | 
23 |   return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/inputs/loopy-cfg.ll:
--------------------------------------------------------------------------------
 1 | ; Has a number of distinct loops in an otherwise simple graph
 2 | 
 3 | define i32 @func(i32 %a, i32 %b) #0 {
 4 | AA:
 5 |   %cmp1 = icmp eq i32 %a, %b
 6 |   br i1 %cmp1, label %BB, label %CC
 7 | 
 8 | BB:
 9 |   br label %BB1
10 | 
11 | BB1:
12 |   br label %BB2
13 | 
14 | BB2:
15 |   %cmp4 = icmp eq i32 %a, %b
16 |   br i1 %cmp4, label %BB3, label %BB
17 | 
18 | BB3:
19 |   br label %BB4
20 | 
21 | BB4:
22 |   %cmp3 = icmp eq i32 %a, %b
23 |   br i1 %cmp3, label %BB3, label %CC
24 | 
25 | CC:
26 |   br label %CC1
27 | 
28 | CC1:
29 |   br label %CC2
30 | 
31 | CC2:
32 |   %cmp2 = icmp eq i32 %a, %b
33 |   br i1 %cmp2, label %DD, label %CC
34 | 
35 | DD:
36 |   ret i32 %a
37 | }
38 | 
39 | 
40 | 


--------------------------------------------------------------------------------
/test/test_simple_bb_pass.py:
--------------------------------------------------------------------------------
 1 | import sys, unittest
 2 | from tools import SamplesTestCase
 3 | 
 4 | 
 5 | OUTPUT_FOR_FACT = '''\
 6 | i32 size 32 bits
 7 | i32 size 32 bits
 8 | i32 size 32 bits
 9 | i32 size 32 bits
10 | i32 size 32 bits
11 | i32 size 32 bits
12 | '''
13 | 
14 | OUTPUT_FOR_TYPES = '''\
15 | %struct.mystruct = type { double, i8, i32, [10 x i8] } size 256 bits
16 | '''
17 | 
18 | PROG = 'simple_bb_pass'
19 | 
20 | class TestSimpleBBPass(SamplesTestCase):
21 |     def test_on_fact(self):
22 |         self.assertSampleOutput([PROG], 'fact.ll', OUTPUT_FOR_FACT)
23 | 
24 |     def test_on_types(self):
25 |         self.assertSampleOutput([PROG], 'types.ll', OUTPUT_FOR_TYPES)
26 | 
27 | if __name__ == '__main__':
28 |   unittest.main()
29 | 


--------------------------------------------------------------------------------
/inputs/cuda_support_header.h:
--------------------------------------------------------------------------------
 1 | /* Minimal declarations for CUDA support.  Testing purposes only. */
 2 | 
 3 | #define __constant__ __attribute__((constant))
 4 | #define __device__ __attribute__((device))
 5 | #define __global__ __attribute__((global))
 6 | #define __host__ __attribute__((host))
 7 | #define __shared__ __attribute__((shared))
 8 | #define __launch_bounds__(...) __attribute__((launch_bounds(__VA_ARGS__)))
 9 | 
10 | struct dim3 {
11 |   unsigned x, y, z;
12 |   __host__ __device__ dim3(unsigned x, unsigned y = 1, unsigned z = 1) : x(x), y(y), z(z) {}
13 | };
14 | 
15 | typedef struct cudaStream *cudaStream_t;
16 | 
17 | int cudaConfigureCall(dim3 gridSize, dim3 blockSize, unsigned sharedSize = 0,
18 |                       cudaStream_t stream = 0);
19 | 


--------------------------------------------------------------------------------
/src_clang/experimental/showattrs.py:
--------------------------------------------------------------------------------
 1 | import pprint
 2 | import sys
 3 | import clang.cindex
 4 | from clang.cindex import CursorKind
 5 | 
 6 | def visitor(cursor):
 7 |     children = list(cursor.get_children())
 8 | 
 9 |     for child in children:
10 |         if (cursor.kind == CursorKind.FUNCTION_DECL and
11 |             child.kind == CursorKind.CUDAGLOBAL_ATTR):
12 |             print 'Function {0} is CUDA global!'.format(cursor.displayname)
13 | 
14 |         visitor(child)
15 | 
16 | index = clang.cindex.Index.create()
17 | # Parse as CUDA
18 | tu = index.parse(sys.argv[1], args=['-x', 'cuda'])
19 | 
20 | diagnostics = list(tu.diagnostics)
21 | if len(diagnostics) > 0:
22 |     print 'There were parse errors'
23 |     pprint.pprint(diagnostics)
24 | else:
25 |     visitor(tu.cursor)
26 | 


--------------------------------------------------------------------------------
/inputs/kernel-signatures.c:
--------------------------------------------------------------------------------
 1 | // Due to the special attributes, this file should be analyzed by Clang in CUDA
 2 | // mode. For example, dump the AST with:
 3 | //
 4 | // $ clang-check inputs/kernel-signatures.c -ast-dump -- -xcuda
 5 | //
 6 | 
 7 | __attribute__((global)) void ker1(float* farr, double* darr, int n) {
 8 | }
 9 | 
10 | __attribute__((device)) void notakernel(int n, float* f1) {
11 | }
12 | 
13 | typedef int* intptr;
14 | 
15 | __attribute__((global)) void ker2(unsigned* uarr, intptr iarr) {
16 | }
17 | 
18 | void foobar() {
19 | }
20 | 
21 | 
22 | template <typename T>
23 | void bazinga(T* k) {
24 | }
25 | 
26 | int booga, chuppa;
27 | 
28 | struct St {
29 |   int b;
30 | 
31 |   void joe(int ii, float ff) {
32 |   	bazinga(&ii);
33 |   	bazinga(&ff);
34 |   }
35 | };
36 | 
37 | 
38 | 


--------------------------------------------------------------------------------
/src_clang/experimental/callexpr.py:
--------------------------------------------------------------------------------
 1 | import pprint
 2 | import sys
 3 | import clang.cindex
 4 | 
 5 | def visitor(cursor):
 6 |   print 'visiting', cursor.kind
 7 |   if cursor.kind == clang.cindex.CursorKind.CALL_EXPR:
 8 |     print 'Found %s [line=%s, col=%s]' % (
 9 |             cursor.displayname, cursor.location.line, cursor.location.column)
10 | 
11 |   children = list(cursor.get_children())
12 |   print '  has {0} children'.format(len(children))
13 |   for child in children:
14 |     visitor(child)
15 | 
16 | index = clang.cindex.Index.create()
17 | # Parse as C++
18 | tu = index.parse(sys.argv[1], args=['-x', 'c++'])
19 | 
20 | diagnostics = list(tu.diagnostics)
21 | if len(diagnostics) > 0:
22 |     print 'There were parse errors'
23 |     pprint.pprint(diagnostics)
24 | else:
25 |     visitor(tu.cursor)
26 | 


--------------------------------------------------------------------------------
/tools/sample-js.js:
--------------------------------------------------------------------------------
 1 | 
 2 |     <script type="text/javascript">
 3 |     var myj = "abo";
 4 |     OnAnchorClick = function(elem_id) {
 5 |         alert(elem_id + myj);
 6 |     }
 7 |     </script>
 8 | </head>
 9 | ...
10 | ...
11 | <body>
12 | <pre class="my-pre">
13 | <span class="ansi-white"></span><span class="ansi-blue"></span><span class="ansi-white"></span><span class="ansi-green ansi-bold">TranslationUnitDecl</span><span class="ansi-white"></span><span class="ansi-yellow"> <a id="anchor_0x3511670"></a><a onclick="OnAnchorClick('0x3511670');" href="#javascript:void(0)">0x3511670</span></a><span class="ansi-white"> &lt;</span><span class="ansi-yellow">&lt;invalid sloc&gt;</span><span class="ansi-white">&gt; </span><span class="ansi-yellow">&lt;invalid sloc&gt;</span><span class="ansi-white">
14 | </span><br/>
15 | 


--------------------------------------------------------------------------------
/tools/template.html:
--------------------------------------------------------------------------------
 1 | <head>
 2 | <style>
 3 | .ansi-bold {
 4 |     font-weight: bold;
 5 | }
 6 | 
 7 | .ansi-black {
 8 |     color: #000000;
 9 | }
10 | 
11 | .ansi-red {
12 |     color: #b21717;
13 | }
14 | 
15 | .ansi-green {
16 |     color: #17b217;
17 | }
18 | 
19 | .ansi-yellow {
20 |     color: #b26717;
21 | }
22 | 
23 | .ansi-blue {
24 |     color: #1717b2;
25 | }
26 | 
27 | .ansi-magenta {
28 |     color: #b217b2;
29 | }
30 | 
31 | .ansi-cyan {
32 |     color: #17b2b2;
33 | }
34 | 
35 | .ansi-white {
36 |     color: #b2b2b2;
37 | }
38 | </style>
39 | </head>
40 | 
41 | <body bgcolor="#000000">
42 | 
43 | <code>hello</code><br/>
44 | hello
45 | 
46 | <br/>
47 | 
48 | 
49 | <code>
50 | <span class="ansi-bold ansi-green">TranslationUnitDecl</span> <span class="ansi-yellow">0x38a3670</span> <span class="ansi-white">implicit</span>
51 | </code>
52 | 
53 | 
54 | 
55 | </body>
56 | 


--------------------------------------------------------------------------------
/inputs/threadidx.ll:
--------------------------------------------------------------------------------
 1 | ; ModuleID = '<stdin>'
 2 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 3 | target triple = "x86_64-unknown-linux-gnu"
 4 | 
 5 | %struct.uint3 = type { i32, i32, i32 }
 6 | 
 7 | @threadIdx = external constant %struct.uint3
 8 | 
 9 | ; Function Attrs: nounwind readnone uwtable
10 | define i32 @foo(i32 %a, i32 %b) #0 {
11 | entry:
12 |   %0 = load i32* getelementptr inbounds (%struct.uint3* @threadIdx, i64 0, i32 1), align 4, !tbaa !1
13 |   %cmp = icmp ugt i32 %0, 5
14 |   %a.b = select i1 %cmp, i32 %a, i32 %b
15 |   ret i32 %a.b
16 | }
17 | 
18 | attributes #0 = { nounwind readnone uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
19 | 
20 | !llvm.ident = !{!0}
21 | 
22 | !0 = !{!"clang version 3.5 "}
23 | !1 = !{!2, !3, i64 4}
24 | !2 = !{!"", !3, i64 0, !3, i64 4, !3, i64 8}
25 | !3 = !{!"int", !4, i64 0}
26 | !4 = !{!"omnipotent char", !5, i64 0}
27 | !5 = !{!"Simple C/C++ TBAA"}
28 | 


--------------------------------------------------------------------------------
/src_clang/experimental/show-mangle.py:
--------------------------------------------------------------------------------
 1 | import pprint
 2 | import sys
 3 | import clang.cindex
 4 | 
 5 | def get_cursor(source, spelling):
 6 |     """Obtain a cursor from a source object.
 7 | 
 8 |     This provides a convenient search mechanism to find a cursor with specific
 9 |     spelling within a source. The first argument can be either a
10 |     TranslationUnit or Cursor instance.
11 | 
12 |     If the cursor is not found, None is returned.
13 |     """
14 |     # Convenience for calling on a TU.
15 | 
16 |     root_cursor = (source if isinstance(source, clang.cindex.Cursor)
17 |                           else source.cursor)
18 | 
19 |     for cursor in root_cursor.walk_preorder():
20 |         if cursor.spelling == spelling:
21 |             return cursor
22 | 
23 |     return None
24 | 
25 | src = '''\
26 | int foo(int, int);
27 | '''
28 | 
29 | tu = clang.cindex.TranslationUnit.from_source('t.cpp',
30 |                                               ['-x', 'c++'],
31 |                                               unsaved_files=[('t.cpp', src)])
32 | 
33 | foo = get_cursor(tu, 'foo')
34 | 
35 | print(foo.mangled_name)
36 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/memcaller.c:
--------------------------------------------------------------------------------
 1 | #include <string.h>
 2 | 
 3 | void* memcpy_impl(void* dst, const void* src, size_t n) {
 4 |   unsigned char* d = dst;
 5 |   const unsigned char* s = src;
 6 |   for (size_t i = 0; i < n; ++i) {
 7 |     d[i] = s[i];
 8 |   }
 9 |   return dst;
10 | }
11 | 
12 | void* memmove_impl(void* dst, const void* src, size_t n) {
13 |   unsigned char* d = dst;
14 |   const unsigned char* s = src;
15 |   if (s < d) {
16 |     while (n--) {
17 |       d[n] = s[n];
18 |     }
19 |   } else {
20 |     for (size_t i = 0; i < n; ++i) {
21 |       d[i] = s[i];
22 |     }
23 |   }
24 |   return dst;
25 | }
26 | 
27 | void* memcpy_caller(void* dst, const void* src, size_t n) {
28 |   return memcpy(dst, src, n);
29 |   //return memcpy_impl(dst, src, n);
30 | }
31 | 
32 | void* memcpy_caller_casting(int* dst, const int* src, size_t n) {
33 |   return memcpy(dst, src, n);
34 | }
35 | 
36 | void* memmove_caller(void* dst, const void* src, size_t n) {
37 |   //return memmove(dst, src, n);
38 |   return memmove_impl(dst, src, n);
39 | }
40 | 
41 | void* memset_caller(void* dst, int c, size_t n) {
42 |   return memset(dst, c, n);
43 | }
44 | 


--------------------------------------------------------------------------------
/inputs/ctor-initializer-list.cpp:
--------------------------------------------------------------------------------
 1 | namespace detail {
 2 | 
 3 | struct Base {};
 4 | 
 5 | constexpr int foo2(int i) { return 2 * i; }
 6 | }
 7 | 
 8 | namespace ns {
 9 | 
10 | // constexpr int foo2(int i) {
11 | // return 2*i;
12 | //}
13 | 
14 | using detail::foo2;
15 | 
16 | constexpr float foo2(float f) { return 2.2 + f; }
17 | 
18 | float joe = foo2(45.4f);
19 | 
20 | namespace Sambusak {
21 | 
22 | constexpr double foo2(double d) { return d * 2.2; }
23 | }
24 | }
25 | 
26 | int iii = ns::foo2(10);
27 | float fla = ns::foo2(4.4f);
28 | double dla = ns::Sambusak::foo2(4.4);
29 | 
30 | void bbbb() {
31 |   auto func = ns::Sambusak::foo2;
32 |   int k = func(10);
33 | }
34 | 
35 | template <typename T> class Foo : public detail::Base {
36 | public:
37 |   typedef typename T::zoo_type arg_type;
38 | 
39 |   Foo(char c) : iguana(c) { f = 0.9; }
40 | 
41 |   Foo(arg_type i_, float f_) : kak(i_), iguana(ns::foo2(i_)), f(f_) {}
42 |   Foo(arg_type i_, float f_, int tt) {
43 |     using ns::foo2;
44 |     iguana = foo2(i_, i_);
45 |   }
46 | 
47 |   Foo() : detail::Base(), iguana(1) {}
48 | 
49 | private:
50 |   int kak;
51 |   int iguana;
52 |   float f;
53 | 
54 |   struct Faborz {
55 |   } faborz;
56 | };
57 | 


--------------------------------------------------------------------------------
/src_clang/experimental/kernel-sigs.py:
--------------------------------------------------------------------------------
 1 | import pprint
 2 | import sys
 3 | import clang.cindex
 4 | from clang.cindex import CursorKind
 5 | 
 6 | 
 7 | def handle_function_decl(fdecl_cursor):
 8 |     children = list(fdecl_cursor.get_children())
 9 | 
10 |     # Only interested in functions that have a CUDAGLOBAL_ATTR attached.
11 |     if not any(c.kind == CursorKind.CUDAGLOBAL_ATTR for c in children):
12 |         return
13 | 
14 |     print fdecl_cursor.displayname
15 | 
16 |     # Look at param decls
17 |     for c in children:
18 |         if c.kind == CursorKind.PARM_DECL:
19 |             print '>> param "{0}" with type "{1}" [{2}, canonical = {3}]'.format(
20 |                     c.spelling, c.type.spelling, c.type.kind.name,
21 |                     c.type.get_canonical().spelling)
22 | 
23 | 
24 | index = clang.cindex.Index.create()
25 | # Parse as CUDA
26 | tu = index.parse(sys.argv[1], args=['-x', 'cuda'])
27 | 
28 | diagnostics = list(tu.diagnostics)
29 | if len(diagnostics) > 0:
30 |     print 'There were parse errors'
31 |     pprint.pprint(diagnostics)
32 | else:
33 |     for c in tu.cursor.walk_preorder():
34 |         if c.kind == CursorKind.FUNCTION_DECL:
35 |             handle_function_decl(c)
36 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <http://unlicense.org/>
25 | 


--------------------------------------------------------------------------------
/test/test_bb_toposort_sccs.py:
--------------------------------------------------------------------------------
 1 | import sys, unittest
 2 | from tools import SamplesTestCase
 3 | 
 4 | OUTPUT_DIAMOND_TOPO = '''\
 5 | Topological sort of func:
 6 |   AA
 7 |   BB
 8 |   CC
 9 |   DD
10 | '''
11 | 
12 | OUTPUT_DIAMOND_PO = '''\
13 | Basic blocks of func in post-order:
14 |   DD
15 |   CC
16 |   BB
17 |   AA
18 | '''
19 | 
20 | OUTPUT_LOOPY_TOPO = '''\
21 | Topological sort of func:
22 |   Detected cycle: edge from BB4 to BB3
23 |   Sorting failed
24 | '''
25 | 
26 | OUTPUT_LOOPY_SCC = '''\
27 | SCCs for func in post-order:
28 |   SCC: DD
29 |   SCC: CC2  CC1  CC
30 |   SCC: BB4  BB3
31 |   SCC: BB2  BB1  BB
32 |   SCC: AA
33 | '''
34 | 
35 | PROG = 'bb_toposort_sccs'
36 | 
37 | class TestBBToposortSCCS(SamplesTestCase):
38 |     def test_topo_on_diamond(self):
39 |         self.assertSampleOutput([PROG, '-topo'], 'diamond-cfg.ll', OUTPUT_DIAMOND_TOPO)
40 | 
41 |     def test_po_on_diamond(self):
42 |         self.assertSampleOutput([PROG, '-po'], 'diamond-cfg.ll', OUTPUT_DIAMOND_PO)
43 | 
44 |     def test_topo_on_loopy(self):
45 |         self.assertSampleOutput([PROG, '-topo'], 'loopy-cfg.ll', OUTPUT_LOOPY_TOPO)
46 | 
47 |     def test_scc_on_loopy(self):
48 |         self.assertSampleOutput([PROG, '-scc'], 'loopy-cfg.ll', OUTPUT_LOOPY_SCC)
49 | 
50 | if __name__ == '__main__':
51 |   unittest.main()
52 | 


--------------------------------------------------------------------------------
/inputs/globals.ll:
--------------------------------------------------------------------------------
 1 | ; ModuleID = '<stdin>'
 2 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 3 | target triple = "x86_64-unknown-linux-gnu"
 4 | 
 5 | @gfloat = common global float 0.000000e+00, align 4
 6 | @gppfloat = common global float** null, align 8
 7 | @gint = common global i32 0, align 4
 8 | 
 9 | ; Function Attrs: nounwind readonly uwtable
10 | define float @foo() #0 {
11 | entry:
12 |   %0 = load float, float* @gfloat, align 4, !tbaa !1
13 |   %1 = load float**, float*** @gppfloat, align 8, !tbaa !5
14 |   %2 = load float*, float** %1, align 8, !tbaa !5
15 |   %3 = load float, float* %2, align 4, !tbaa !1
16 |   %add = fadd float %0, %3
17 |   ret float %add
18 | }
19 | 
20 | attributes #0 = { nounwind readonly uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
21 | 
22 | !llvm.ident = !{!0}
23 | 
24 | !0 = !{!"clang version 3.7.0 (http://llvm.org/git/clang 805ac0a233be64ffeeff2334db1873760c1588e9) (http://llvm.org/git/llvm.git 5109ec06a641f039775e1a6bcd7d50bb04dbb8f6)"}
25 | !1 = !{!2, !2, i64 0}
26 | !2 = !{!"float", !3, i64 0}
27 | !3 = !{!"omnipotent char", !4, i64 0}
28 | !4 = !{!"Simple C/C++ TBAA"}
29 | !5 = !{!6, !6, i64 0}
30 | !6 = !{!"any pointer", !3, i64 0}
31 | 


--------------------------------------------------------------------------------
/tools/show-cfg.py:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------------------------------------
 2 | # Script for showing the CFG of the given LLVM IR file.
 3 | # 'dot' must be installed. If 'eog' is installed, it's popped to show the
 4 | # produced image.
 5 | #
 6 | # Eli Bendersky (eliben@gmail.com)
 7 | # This code is in the public domain
 8 | #-------------------------------------------------------------------------------
 9 | import os, re, subprocess, sys
10 | import tempfile
11 | import os.path
12 | 
13 | LLVMDIR = os.path.expanduser('~/llvm/build/svn-make-debug/Debug+Asserts/bin')
14 | OPT = os.path.join(LLVMDIR, 'opt')
15 | 
16 | def show_dot(filename):
17 |     outpng = os.path.join(tempfile.gettempdir(), filename + '.png')
18 |     subprocess.check_call(['dot', '-Tpng', filename, '-o', outpng])
19 |     print('Created', outpng, '... Running eog')
20 |     subprocess.call('eog ' + outpng + ' &', shell=True)
21 | 
22 | def main():
23 |     opt_out = subprocess.check_output(
24 |         [OPT, '-dot-cfg-only', '-disable-output', sys.argv[1]],
25 |         stderr=subprocess.STDOUT)  # opt prints stuff to stderr too o_O
26 |     for line in opt_out.decode('utf-8').splitlines():
27 |         m = re.search("Writing '(cfg\.[^\.]+\.dot)", line)
28 |         if m:
29 |             show_dot(m.group(1))
30 |         else:
31 |             print('Cannot parse line:', line)
32 | 
33 | if __name__ == '__main__':
34 |     main()
35 | 


--------------------------------------------------------------------------------
/inputs/twodoublefoo.ll:
--------------------------------------------------------------------------------
 1 | ; ModuleID = 'inputs/twodoublefoo.c'
 2 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 3 | target triple = "x86_64-unknown-linux-gnu"
 4 | 
 5 | ; Function Attrs: nounwind readnone uwtable
 6 | define double @foo(double %a, double %b) #0 {
 7 |   %1 = fmul double %a, 2.000000e+00
 8 |   %2 = fadd double %1, %b
 9 |   ret double %2
10 | }
11 | 
12 | ; Function Attrs: nounwind readnone uwtable
13 | define double @bar(double %a, double %b) #0 {
14 |   %1 = tail call fastcc double @internal(double %a, double %b)
15 |   %2 = fmul double %1, 1.000000e+01
16 |   ret double %2
17 | }
18 | 
19 | ; Function Attrs: noinline nounwind readnone uwtable
20 | define internal fastcc double @internal(double %a, double %b) #1 {
21 |   %1 = fmul double %a, %b
22 |   ret double %1
23 | }
24 | 
25 | attributes #0 = { nounwind readnone uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
26 | attributes #1 = { noinline nounwind readnone uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
27 | 
28 | !llvm.ident = !{!0}
29 | 
30 | !0 = !{!"clang version 3.7.0 (tags/RELEASE_370/final)"}
31 | 


--------------------------------------------------------------------------------
/src_llvm/access_debug_metadata.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // This is currently ad-hoc
 3 | //
 4 | // Eli Bendersky (eliben@gmail.com)
 5 | // This code is in the public domain
 6 | //------------------------------------------------------------------------------
 7 | #include "llvm/IR/Metadata.h"
 8 | #include "llvm/IR/Module.h"
 9 | #include "llvm/IRReader/IRReader.h"
10 | #include "llvm/Pass.h"
11 | #include "llvm/Support/SourceMgr.h"
12 | #include "llvm/Support/raw_ostream.h"
13 | 
14 | using namespace llvm;
15 | 
16 | int main(int argc, char **argv) {
17 |   if (argc < 2) {
18 |     errs() << "Usage: " << argv[0] << " <IR file>\n";
19 |     return 1;
20 |   }
21 | 
22 |   // Parse the input LLVM IR file into a module.
23 |   SMDiagnostic Err;
24 |   LLVMContext Context;
25 |   std::unique_ptr<Module> Mod(parseIRFile(argv[1], Err, Context));
26 |   if (!Mod) {
27 |     Err.print(argv[0], errs());
28 |     return 1;
29 |   }
30 | 
31 |   // Go over all named mdnodes in the module
32 |   for (Module::const_named_metadata_iterator I = Mod->named_metadata_begin(),
33 |                                              E = Mod->named_metadata_end();
34 |        I != E; ++I) {
35 |     outs() << "Found MDNode:\n";
36 |     // These dumps only work with LLVM built with a special cmake flag enabling
37 |     // dumps.
38 |     // I->dump();
39 | 
40 |     for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
41 |       Metadata *Op = I->getOperand(i);
42 |       if (auto *N = dyn_cast<MDNode>(Op)) {
43 |         outs() << "  Has MDNode operand:\n  ";
44 |         // N->dump();
45 |         outs() << "  " << N->getNumOperands() << " operands\n";
46 |       }
47 |     }
48 |   }
49 | 
50 |   return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/src_llvm/hello_pass.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // hello_pass LLVM sample. Demonstrates:
 3 | //
 4 | // * Creating a "plugin" pass loaded dynamically by opt.
 5 | // * Implementing getAnalysisUsage to notify the pass manager about possible
 6 | //   interactions with other passes.
 7 | //
 8 | // Once the .so is built, it can be loaded by opt. For example:
 9 | //
10 | // $ opt -load build/hello_pass.so -hello-funcs <ir-file> > /dev/null
11 | //
12 | // Taken from the LLVM distribution with some modifications. LLVM's license
13 | // applies.
14 | //------------------------------------------------------------------------------
15 | #include "llvm/IR/Function.h"
16 | #include "llvm/Pass.h"
17 | #include "llvm/Support/raw_ostream.h"
18 | 
19 | using namespace llvm;
20 | 
21 | // HelloFuncs - emit the names of functions encountered.
22 | struct HelloFuncs : public FunctionPass {
23 |   HelloFuncs() : FunctionPass(ID) {}
24 | 
25 |   virtual bool runOnFunction(Function &F) {
26 |     outs() << "Hello: ";
27 |     outs().write_escaped(F.getName()) << '\n';
28 |     return false;
29 |   }
30 | 
31 |   // We don't modify the program, so we preserve all analyses.
32 |   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
33 |     AU.setPreservesAll();
34 |   }
35 | 
36 |   // The address of this member is used to uniquely identify the class. This is
37 |   // used by LLVM's own RTTI mechanism.
38 |   static char ID;
39 | };
40 | 
41 | char HelloFuncs::ID = 0;
42 | 
43 | // Register our pass with the pass manager in opt. For more information, see:
44 | // http://llvm.org/docs/WritingAnLLVMPass.html
45 | static RegisterPass<HelloFuncs>
46 |     X("hello-funcs", "Hello World Pass (with getAnalysisUsage implemented)");
47 | 


--------------------------------------------------------------------------------
/src_llvm/experimental/loop_info.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // Experimental sample; use at your own peril.
 3 | //
 4 | // Eli Bendersky (eliben@gmail.com)
 5 | // This code is in the public domain
 6 | //------------------------------------------------------------------------------
 7 | #include "llvm/ADT/DenseMap.h"
 8 | #include "llvm/ADT/PostOrderIterator.h"
 9 | #include "llvm/Analysis/LoopInfo.h"
10 | #include "llvm/IR/DataLayout.h"
11 | #include "llvm/IR/Instruction.h"
12 | #include "llvm/IR/Instructions.h"
13 | #include "llvm/IR/LegacyPassManager.h"
14 | #include "llvm/IR/Module.h"
15 | #include "llvm/IRReader/IRReader.h"
16 | #include "llvm/Pass.h"
17 | #include "llvm/Support/SourceMgr.h"
18 | #include "llvm/Support/raw_ostream.h"
19 | #include <string>
20 | #include <vector>
21 | 
22 | using namespace llvm;
23 | 
24 | class AnalyzeLoops : public FunctionPass {
25 | public:
26 |   AnalyzeLoops() : FunctionPass(ID) {}
27 | 
28 |   void getAnalysisUsage(AnalysisUsage &AU) const { AU.addRequired<LoopInfo>(); }
29 | 
30 |   virtual bool runOnFunction(Function &F) {
31 |     LoopInfo &LI = getAnalysis<LoopInfo>();
32 |     for (LoopInfo::iterator L = LI.begin(), LE = LI.end(); L != LE; ++L) {
33 |       (*L)->dump();
34 |     }
35 |     return false;
36 |   }
37 | 
38 |   static char ID;
39 | };
40 | 
41 | char AnalyzeLoops::ID = 0;
42 | 
43 | int main(int argc, char **argv) {
44 |   if (argc < 2) {
45 |     errs() << "Usage: " << argv[0] << " <IR file>\n";
46 |     return 1;
47 |   }
48 | 
49 |   // Parse the input LLVM IR file into a module.
50 |   SMDiagnostic Err;
51 |   LLVMContext Context;
52 |   std::unique_ptr<Module> Mod(parseIRFile(argv[1], Err, Context));
53 |   if (!Mod) {
54 |     Err.print(argv[0], errs());
55 |     return 1;
56 |   }
57 | 
58 |   // Create a pass manager and fill it with the passes we want to run.
59 |   PassManager PM;
60 |   PM.add(new LoopInfo());
61 |   PM.add(new AnalyzeLoops());
62 |   PM.run(*Mod);
63 | 
64 |   return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/tools/gen_c_straightline.py:
--------------------------------------------------------------------------------
 1 | """Run with --numops=<N> to customize the size of the output.
 2 | 
 3 | Emits the function to stdout.
 4 | """
 5 | import argparse
 6 | import random
 7 | 
 8 | FUNC_TEMPLATE = '''\
 9 | void foo(const int* in1, const int* in2, int* out) {{
10 | {func_body}
11 | }}
12 | '''
13 | 
14 | 
15 | def main():
16 |     argparser = argparse.ArgumentParser()
17 |     argparser.add_argument('--numops', type=int, default=20)
18 |     args = argparser.parse_args()
19 | 
20 |     numops = args.numops
21 |     bodylines = []
22 | 
23 |     def emit_new_temp(n):
24 |         bodylines.append('  int temp{0};'.format(n))
25 | 
26 |     def emit_op(dest, inputs):
27 |         line = '  {0} = '.format(dest)
28 |         for n, inp in enumerate(inputs):
29 |             line += inp
30 |             if n < len(inputs) - 1:
31 |                 line += ' {0} '.format(random.choice(('+', '-', '*', '/', '%')))
32 |         line += ';'
33 |         bodylines.append(line)
34 | 
35 |     ntemps = 2
36 |     emit_new_temp(0)
37 |     emit_new_temp(1)
38 | 
39 |     for i in range(numops):
40 |         # Decide on the destination. 50% chance it goes to out, 50% to new
41 |         # temporary.
42 |         if random.random() > 0.5:
43 |             dest = 'out[{0}]'.format(random.randint(0, numops))
44 |         else:
45 |             emit_new_temp(ntemps)
46 |             dest = 'temp{0}'.format(ntemps)
47 |             ntemps += 1
48 | 
49 |         # Decide how many inputs it will have and where they come from (in1, in2
50 |         # or temporaries)
51 |         num_inputs = random.randint(2, 6)
52 |         inputs = []
53 |         for ni in range(num_inputs):
54 |             choice = random.random()
55 |             if choice > 0.8:
56 |                 inp = 'in1[{0}]'.format(random.randint(0, numops))
57 |             elif choice > 0.6:
58 |                 inp = 'in2[{0}]'.format(random.randint(0, numops))
59 |             else:
60 |                 # pick temp num at random
61 |                 inp = 'temp{0}'.format(random.randint(0, ntemps - 1))
62 |             inputs.append(inp)
63 |         emit_op(dest, inputs)
64 | 
65 |     print(FUNC_TEMPLATE.format(func_body='\n'.join(bodylines)))
66 | 
67 | 
68 | if __name__ == '__main__':
69 |     main()
70 | 


--------------------------------------------------------------------------------
/inputs/typeuse.cpp:
--------------------------------------------------------------------------------
 1 | namespace Frob {
 2 | 
 3 | template <typename T> struct Homer { T a, b; };
 4 | }
 5 | 
 6 | using namespace Frob;
 7 | 
 8 | Homer<float> h;
 9 | 
10 | void foobar(Frob::Homer<double> hh) {}
11 | 
12 | template <typename T> void templated() { T t; }
13 | 
14 | void joe() {
15 |   templated<Homer<float>>();
16 | 
17 |   int i[] = {10, 20};
18 |   Homer<double> *h = reinterpret_cast<Homer<double> *>(i);
19 | }
20 | 
21 | template <typename Scalar1, typename Scalar2> struct scalar_multiple2_op {};
22 | 
23 | template <typename UnaryOp, typename XprType> class CwiseUnaryOp {};
24 | 
25 | inline const CwiseUnaryOp<scalar_multiple2_op<int, std::complex<int>>, float>
26 | operator*(const Homer<int> &scalar) const {}
27 | 
28 | // template <typename T, typename U>
29 | // class Container {
30 | //   T t;
31 | //   Homer<T> ht;
32 | // };
33 | 
34 | // template <typename U>
35 | // class Container<Homer<float>, U> {
36 | // };
37 | 
38 | // template <>
39 | // class Container<Homer<float>, int> {};
40 | 
41 | // template <>
42 | // class Container<Homer<float>, float> {} ;
43 | 
44 | // /** Overloaded for efficient real matrix times complex scalar value */
45 | // EIGEN_DEVICE_FUNC
46 | // inline const
47 | // CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >,
48 | // const Derived> operator*(const std::complex<Scalar>& scalar) const
49 | // {
50 | //   return
51 | //   CwiseUnaryOp<internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >,
52 | //   const Derived>
53 | //     (*static_cast<const Derived*>(this),
54 | //     internal::scalar_multiple2_op<Scalar,std::complex<Scalar> >(scalar));
55 | // }
56 | 
57 | // template<typename Scalar1, typename Scalar2>
58 | // struct scalar_multiple2_op {
59 | //   typedef typename scalar_product_traits<Scalar1,Scalar2>::ReturnType
60 | //   result_type; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
61 | //   scalar_multiple2_op(const scalar_multiple2_op& other) :
62 | //   m_other(other.m_other) { } EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
63 | //   scalar_multiple2_op(const Scalar2& other) : m_other(other) { }
64 | //   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE result_type operator() (const
65 | //   Scalar1& a) const { return a * m_other; } typename
66 | //   add_const_on_value_type<typename NumTraits<Scalar2>::Nested>::type m_other;
67 | // };
68 | 


--------------------------------------------------------------------------------
/src_llvm/simple_module_pass.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // simple_module_pass LLVM sample. Demonstrates:
 3 | //
 4 | // * How to write a ModulePass
 5 | // * How to iterate over the global values in a module, and access their names
 6 | //   and types.
 7 | // * How to produce a string representation of a LLVM type.
 8 | //
 9 | // Eli Bendersky (eliben@gmail.com)
10 | // This code is in the public domain
11 | //------------------------------------------------------------------------------
12 | #include "llvm/IR/LegacyPassManager.h"
13 | #include "llvm/IR/Module.h"
14 | #include "llvm/IRReader/IRReader.h"
15 | #include "llvm/Pass.h"
16 | #include "llvm/Support/SourceMgr.h"
17 | #include "llvm/Support/raw_ostream.h"
18 | 
19 | using namespace llvm;
20 | 
21 | // Helper method for converting the name of a LLVM type to a string
22 | static std::string LLVMTypeAsString(const Type *T) {
23 |   std::string TypeName;
24 |   raw_string_ostream N(TypeName);
25 |   T->print(N);
26 |   return N.str();
27 | }
28 | 
29 | class GVNames : public ModulePass {
30 | public:
31 |   GVNames() : ModulePass(ID) {}
32 | 
33 |   virtual bool runOnModule(Module &M) {
34 |     for (Module::const_global_iterator GI = M.global_begin(),
35 |                                        GE = M.global_end();
36 |          GI != GE; ++GI) {
37 |       outs() << "Found global named \"" << GI->getName()
38 |              << "\": type = " << LLVMTypeAsString(GI->getType()) << "\n";
39 |     }
40 |     return false;
41 |   }
42 | 
43 |   // The address of this member is used to uniquely identify the class. This is
44 |   // used by LLVM's own RTTI mechanism.
45 |   static char ID;
46 | };
47 | 
48 | char GVNames::ID = 0;
49 | 
50 | int main(int argc, char **argv) {
51 |   if (argc < 2) {
52 |     errs() << "Usage: " << argv[0] << " <IR file>\n";
53 |     return 1;
54 |   }
55 | 
56 |   // Parse the input LLVM IR file into a module.
57 |   SMDiagnostic Err;
58 |   LLVMContext Context;
59 |   std::unique_ptr<Module> Mod(parseIRFile(argv[1], Err, Context));
60 |   if (!Mod) {
61 |     Err.print(argv[0], errs());
62 |     return 1;
63 |   }
64 | 
65 |   // Create a pass manager and fill it with the passes we want to run.
66 |   legacy::PassManager PM;
67 |   PM.add(new GVNames());
68 |   PM.run(*Mod);
69 | 
70 |   return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/inputs/fact.ll:
--------------------------------------------------------------------------------
 1 | ; ModuleID = 'fact.c'
 2 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 3 | target triple = "x86_64-unknown-linux-gnu"
 4 | 
 5 | ; Function Attrs: nounwind
 6 | define i32 @mult(i32 %a, i32 %b) #0 {
 7 |   %1 = alloca i32, align 4
 8 |   %2 = alloca i32, align 4
 9 |   %i = alloca i32, align 4
10 |   %s = alloca i32, align 4
11 |   store i32 %a, i32* %1, align 4
12 |   store i32 %b, i32* %2, align 4
13 |   store i32 0, i32* %s, align 4
14 |   store i32 0, i32* %i, align 4
15 |   br label %3
16 | 
17 | ; <label>:3                                       ; preds = %11, %0
18 |   %4 = load i32, i32* %i, align 4
19 |   %5 = load i32, i32* %1, align 4
20 |   %6 = icmp ult i32 %4, %5
21 |   br i1 %6, label %7, label %14
22 | 
23 | ; <label>:7                                       ; preds = %3
24 |   %8 = load i32, i32* %2, align 4
25 |   %9 = load i32, i32* %s, align 4
26 |   %10 = add i32 %9, %8
27 |   store i32 %10, i32* %s, align 4
28 |   br label %11
29 | 
30 | ; <label>:11                                      ; preds = %7
31 |   %12 = load i32, i32* %i, align 4
32 |   %13 = add i32 %12, 1
33 |   store i32 %13, i32* %i, align 4
34 |   br label %3
35 | 
36 | ; <label>:14                                      ; preds = %3
37 |   %15 = load i32, i32* %s, align 4
38 |   ret i32 %15
39 | }
40 | 
41 | ; Function Attrs: nounwind
42 | define i32 @fact(i32 %a) #0 {
43 |   %1 = alloca i32, align 4
44 |   %2 = alloca i32, align 4
45 |   store i32 %a, i32* %2, align 4
46 |   %3 = load i32, i32* %2, align 4
47 |   %4 = icmp ule i32 %3, 1
48 |   br i1 %4, label %5, label %6
49 | 
50 | ; <label>:5                                       ; preds = %0
51 |   store i32 1, i32* %1
52 |   br label %12
53 | 
54 | ; <label>:6                                       ; preds = %0
55 |   %7 = load i32, i32* %2, align 4
56 |   %8 = load i32, i32* %2, align 4
57 |   %9 = sub i32 %8, 1
58 |   %10 = call i32 @fact(i32 %9)
59 |   %11 = mul i32 %7, %10
60 |   store i32 %11, i32* %1
61 |   br label %12
62 | 
63 | ; <label>:12                                      ; preds = %6, %5
64 |   %13 = load i32, i32* %1
65 |   ret i32 %13
66 | }
67 | 
68 | attributes #0 = { nounwind "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-realign-stack" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
69 | 
70 | !llvm.ident = !{!0}
71 | 
72 | !0 = !{!"clang version 3.5 (199390)"}
73 | 


--------------------------------------------------------------------------------
/src_clang/plugin_print_funcnames.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // plugin_print_funcnames Clang sample. Demonstrates:
 3 | //
 4 | // * How to create a Clang plugin.
 5 | // * How to use AST actions to access the AST of the parsed code.
 6 | //
 7 | // Once the .so is built, it can be loaded by Clang. For example:
 8 | //
 9 | // $ clang -cc1 -load build/plugin_print_funcnames.so -plugin print-fns <cfile>
10 | //
11 | // Taken from the Clang distribution. LLVM's license applies.
12 | //------------------------------------------------------------------------------
13 | #include "clang/AST/AST.h"
14 | #include "clang/AST/ASTConsumer.h"
15 | #include "clang/Frontend/CompilerInstance.h"
16 | #include "clang/Frontend/FrontendPluginRegistry.h"
17 | #include "llvm/Support/raw_ostream.h"
18 | 
19 | using namespace clang;
20 | 
21 | namespace {
22 | 
23 | class PrintFunctionsConsumer : public ASTConsumer {
24 | public:
25 |   virtual bool HandleTopLevelDecl(DeclGroupRef DG) {
26 |     for (DeclGroupRef::iterator i = DG.begin(), e = DG.end(); i != e; ++i) {
27 |       const Decl *D = *i;
28 |       if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
29 |         llvm::errs() << "top-level-decl: \"" << ND->getNameAsString() << "\"\n";
30 |     }
31 | 
32 |     return true;
33 |   }
34 | };
35 | 
36 | class PrintFunctionNamesAction : public PluginASTAction {
37 | protected:
38 |   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
39 |                                                  llvm::StringRef) {
40 |     return llvm::make_unique<PrintFunctionsConsumer>();
41 |   }
42 | 
43 |   bool ParseArgs(const CompilerInstance &CI,
44 |                  const std::vector<std::string> &args) {
45 |     for (unsigned i = 0, e = args.size(); i != e; ++i) {
46 |       llvm::errs() << "PrintFunctionNames arg = " << args[i] << "\n";
47 | 
48 |       // Example error handling.
49 |       if (args[i] == "-an-error") {
50 |         DiagnosticsEngine &D = CI.getDiagnostics();
51 |         unsigned DiagID = D.getCustomDiagID(DiagnosticsEngine::Error,
52 |                                             "invalid argument '%0'");
53 |         D.Report(DiagID) << args[i];
54 |         return false;
55 |       }
56 |     }
57 |     if (args.size() && args[0] == "help")
58 |       PrintHelp(llvm::errs());
59 | 
60 |     return true;
61 |   }
62 |   void PrintHelp(llvm::raw_ostream &ros) {
63 |     ros << "Help for PrintFunctionNames plugin goes here\n";
64 |   }
65 | };
66 | }
67 | 
68 | static FrontendPluginRegistry::Add<PrintFunctionNamesAction>
69 |     X("print-fns", "print function names");
70 | 


--------------------------------------------------------------------------------
/src_llvm/simple_bb_pass.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // simple_bb_pass LLVM sample. Demonstrates:
 3 | //
 4 | // * How to write a BasicBlockPass
 5 | // * How to iterate over instructions in a basic block and detect instructions
 6 | //   of a certain type.
 7 | // * How to query for a type's size using the module's data layout.
 8 | //
 9 | // Eli Bendersky (eliben@gmail.com)
10 | // This code is in the public domain
11 | //------------------------------------------------------------------------------
12 | #include "llvm/IR/DataLayout.h"
13 | #include "llvm/IR/Instruction.h"
14 | #include "llvm/IR/Instructions.h"
15 | #include "llvm/IR/LegacyPassManager.h"
16 | #include "llvm/IR/Module.h"
17 | #include "llvm/IRReader/IRReader.h"
18 | #include "llvm/Pass.h"
19 | #include "llvm/Support/SourceMgr.h"
20 | #include "llvm/Support/raw_ostream.h"
21 | 
22 | using namespace llvm;
23 | 
24 | class AllocaSizeDetect : public BasicBlockPass {
25 | public:
26 |   AllocaSizeDetect() : BasicBlockPass(ID) {}
27 | 
28 |   virtual bool runOnBasicBlock(BasicBlock &BB) {
29 |     const DataLayout &DL = BB.getModule()->getDataLayout();
30 |     for (BasicBlock::iterator II = BB.begin(), II_e = BB.end(); II != II_e;
31 |          ++II) {
32 |       // Iterate over each instruction in the BasicBlock. If the instruction
33 |       // is an alloca, dump its type and query the type's size.
34 |       if (AllocaInst *Alloca = dyn_cast<AllocaInst>(II)) {
35 |         Type *AllocType = Alloca->getAllocatedType();
36 |         AllocType->print(outs());
37 |         outs() << " size " << DL.getTypeSizeInBits(AllocType) << " bits\n";
38 |       }
39 |     }
40 | 
41 |     // Return false to signal that the basic block was not modified by this
42 |     // pass.
43 |     return false;
44 |   }
45 | 
46 |   // The address of this member is used to uniquely identify the class. This is
47 |   // used by LLVM's own RTTI mechanism.
48 |   static char ID;
49 | };
50 | 
51 | char AllocaSizeDetect::ID = 0;
52 | 
53 | int main(int argc, char **argv) {
54 |   if (argc < 2) {
55 |     errs() << "Usage: " << argv[0] << " <IR file>\n";
56 |     return 1;
57 |   }
58 | 
59 |   // Parse the input LLVM IR file into a module.
60 |   SMDiagnostic Err;
61 |   LLVMContext Context;
62 |   std::unique_ptr<Module> Mod(parseIRFile(argv[1], Err, Context));
63 |   if (!Mod) {
64 |     Err.print(argv[0], errs());
65 |     return 1;
66 |   }
67 | 
68 |   // Create a pass manager and fill it with the passes we want to run.
69 |   legacy::PassManager PM;
70 |   PM.add(new AllocaSizeDetect());
71 |   PM.run(*Mod);
72 | 
73 |   return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/src_llvm/analyze_geps.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // analyze_geps LLVM sample. Demonstrates:
 3 | //
 4 | // * How to write a BasicBlockPass and iterate over instructions.
 5 | // * Infer all kinds of information about GEP instructions.
 6 | //
 7 | // Eli Bendersky (eliben@gmail.com)
 8 | // This code is in the public domain
 9 | //------------------------------------------------------------------------------
10 | #include "llvm/IR/Instruction.h"
11 | #include "llvm/IR/Instructions.h"
12 | #include "llvm/IR/LegacyPassManager.h"
13 | #include "llvm/IR/Module.h"
14 | #include "llvm/IRReader/IRReader.h"
15 | #include "llvm/Pass.h"
16 | #include "llvm/Support/SourceMgr.h"
17 | #include "llvm/Support/raw_ostream.h"
18 | 
19 | #include <string>
20 | 
21 | using namespace llvm;
22 | 
23 | // Helper method for converting LLVM entities that support the print() method
24 | // to a string.
25 | template <typename T> static std::string ToString(const T *Obj) {
26 |   std::string S;
27 |   raw_string_ostream OS(S);
28 |   Obj->print(OS);
29 |   return OS.str();
30 | }
31 | 
32 | class AnalyzeGEPPass : public BasicBlockPass {
33 | public:
34 |   AnalyzeGEPPass() : BasicBlockPass(ID) {}
35 | 
36 |   virtual bool runOnBasicBlock(BasicBlock &BB) {
37 |     for (auto II = BB.begin(), II_e = BB.end(); II != II_e; ++II) {
38 |       if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(II)) {
39 |         outs() << "Found GEP:\n";
40 |         // These dumps only work with LLVM built with a special cmake flag
41 |         // enabling dumps.
42 |         // GEP->dump();
43 |         outs() << "  The type is: " << ToString(GEP->getType()) << "\n";
44 |         outs() << "  The pointer operand is: "
45 |                << ToString(GEP->getPointerOperand()) << "\n";
46 |         outs() << "  Indices: ";
47 |         for (auto Idx = GEP->idx_begin(), IdxE = GEP->idx_end(); Idx != IdxE;
48 |              ++Idx) {
49 |           outs() << "[" << ToString(Idx->get()) << "] ";
50 |         }
51 |         outs() << "\n";
52 |       }
53 |     }
54 | 
55 |     // Return false to signal that the basic block was not modified by this
56 |     // pass.
57 |     return false;
58 |   }
59 | 
60 |   // The address of this member is used to uniquely identify the class. This is
61 |   // used by LLVM's own RTTI mechanism.
62 |   static char ID;
63 | };
64 | 
65 | char AnalyzeGEPPass::ID = 0;
66 | 
67 | int main(int argc, char **argv) {
68 |   if (argc < 2) {
69 |     errs() << "Usage: " << argv[0] << " <IR file>\n";
70 |     return 1;
71 |   }
72 | 
73 |   // Parse the input LLVM IR file into a module.
74 |   SMDiagnostic Err;
75 |   LLVMContext Context;
76 |   std::unique_ptr<Module> Mod(parseIRFile(argv[1], Err, Context));
77 |   if (!Mod) {
78 |     Err.print(argv[0], errs());
79 |     return 1;
80 |   }
81 | 
82 |   // Create a pass manager and fill it with the passes we want to run.
83 |   legacy::PassManager PM;
84 |   PM.add(new AnalyzeGEPPass());
85 |   PM.run(*Mod);
86 | 
87 |   return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/src_clang/experimental/toplevel_decls.cpp:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // Experimental sample; use at your own peril.
 3 | //
 4 | // Eli Bendersky (eliben@gmail.com)
 5 | // This code is in the public domain
 6 | //------------------------------------------------------------------------------
 7 | #include <sstream>
 8 | #include <string>
 9 | 
10 | #include "clang/AST/AST.h"
11 | #include "clang/AST/ASTConsumer.h"
12 | #include "clang/Frontend/ASTConsumers.h"
13 | #include "clang/Frontend/CompilerInstance.h"
14 | #include "clang/Frontend/FrontendActions.h"
15 | #include "clang/Rewrite/Core/Rewriter.h"
16 | #include "clang/Tooling/CommonOptionsParser.h"
17 | #include "clang/Tooling/Tooling.h"
18 | #include "llvm/Support/raw_ostream.h"
19 | 
20 | using namespace clang;
21 | using namespace clang::driver;
22 | using namespace clang::tooling;
23 | 
24 | static llvm::cl::OptionCategory ToolingSampleCategory("Tooling Sample");
25 | 
26 | class MyASTConsumer : public ASTConsumer {
27 | public:
28 |   MyASTConsumer(Rewriter &R) {}
29 | 
30 |   // This gets called *while the source is being parsed* - the full AST does not
31 |   // exist yet.
32 |   bool HandleTopLevelDecl(DeclGroupRef DR) override {
33 |     for (DeclGroupRef::iterator b = DR.begin(), e = DR.end(); b != e; ++b) {
34 |       // llvm::errs() << "This is a toplevel decl!\n";
35 |       //(*b)->dump();
36 |     }
37 |     return true;
38 |   }
39 | 
40 |   // This gets called only when the full TU is completely parsed.
41 |   void HandleTranslationUnit(ASTContext &Context) {
42 |     llvm::errs() << "********* The whole TU *************\n";
43 |     Context.getTranslationUnitDecl()->dump();
44 | 
45 |     llvm::errs() << "****** going over the decls stored in it:\n";
46 |     for (auto *D : Context.getTranslationUnitDecl()->decls()) {
47 |       llvm::errs() << "Decl in the TU:\n";
48 |       D->dump();
49 |       llvm::errs() << "Its start location is: '"
50 |                    << D->getLocStart().printToString(Context.getSourceManager())
51 |                    << "'\n";
52 |     }
53 |   }
54 | };
55 | 
56 | class MyFrontendAction : public ASTFrontendAction {
57 | public:
58 |   MyFrontendAction() {}
59 |   void EndSourceFileAction() override {
60 |     SourceManager &SM = TheRewriter.getSourceMgr();
61 |     llvm::errs() << "** EndSourceFileAction for: "
62 |                  << SM.getFileEntryForID(SM.getMainFileID())->getName() << "\n";
63 | 
64 |     // Now emit the rewritten buffer.
65 |     // TheRewriter.getEditBuffer(SM.getMainFileID()).write(llvm::outs());
66 |   }
67 | 
68 |   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
69 |                                                  StringRef file) override {
70 |     SourceManager &SM = CI.getSourceManager();
71 |     llvm::errs() << "** Creating AST consumer for: " << file << "\n";
72 |     llvm::errs() << "  Main file ID: "
73 |                  << SM.getFileEntryForID(SM.getMainFileID())->getName() << "\n";
74 |     SM.PrintStats();
75 |     TheRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
76 |     return llvm::make_unique<MyASTConsumer>(TheRewriter);
77 |   }
78 | 
79 | private:
80 |   Rewriter TheRewriter;
81 | };
82 | 
83 | int main(int argc, const char **argv) {
84 |   CommonOptionsParser op(argc, argv, ToolingSampleCategory);
85 |   ClangTool Tool(op.getCompilations(), op.getSourcePathList());
86 |   return Tool.run(newFrontendActionFactory<MyFrontendAction>().get());
87 | }
88 | 


--------------------------------------------------------------------------------
/using_clang_toolchain/Makefile:
--------------------------------------------------------------------------------
 1 | #-------------------------------------------------------------------------------
 2 | # Eli Bendersky (eliben@gmail.com)
 3 | # This code is in the public domain
 4 | #-------------------------------------------------------------------------------
 5 | 
 6 | # The following variables will likely need to be modified, depending on where
 7 | # and how you built LLVM & Clang.
 8 | 
 9 | # LLVM_BUILD_PATH is the directory in which you built LLVM - where you ran
10 | # configure or cmake.
11 | # For linking vs. a binary build of LLVM, point to the main untarred directory.
12 | LLVM_BUILD_PATH = $$HOME/llvm/build/svn-make-debug
13 | #LLVM_BUILD_PATH := $$HOME/llvm/build/gh-ninja-debug
14 | #LLVM_BUILD_PATH := $$HOME/llvm/build/svn-ninja-release
15 | 
16 | # LLVM_BIN_PATH is the directory where binaries are placed by the LLVM build
17 | # process. It should contain the tools like opt, llc and clang. The default
18 | # reflects a debug build with autotools (configure & make).
19 | LLVM_BIN_PATH = $(LLVM_BUILD_PATH)/Debug+Asserts/bin
20 | #LLVM_BIN_PATH := $(LLVM_BUILD_PATH)/bin
21 | 
22 | CLANG    := $(LLVM_BIN_PATH)/clang
23 | CLANGXX  := $(LLVM_BIN_PATH)/clang++
24 | LLVMLINK := $(LLVM_BIN_PATH)/llvm-link
25 | LLC      := $(LLVM_BIN_PATH)/llc
26 | OPT 		 := $(LLVM_BIN_PATH)/opt
27 | LD       := $(LLVM_BIN_PATH)/clang++
28 | 
29 | CFLAGS    := -std=c99 -Wall
30 | CXXFLAGS  := -Wall
31 | CXX11FLAG := -std=c++11
32 | 
33 | define colorecho
34 | 	@tput setaf 6
35 | 	@echo $1
36 | 	@tput sgr0
37 | endef
38 | 
39 | BUILDDIR := build
40 | 
41 | all: make_builddir \
42 | 	$(BUILDDIR)/simple \
43 | 	$(BUILDDIR)/exceptions1 \
44 | 	$(BUILDDIR)/simple-from-bitcode \
45 | 	$(BUILDDIR)/cxx11-range-sample
46 | 
47 | make_builddir:
48 | 	@test -d $(BUILDDIR) || mkdir $(BUILDDIR)
49 | 
50 | $(BUILDDIR)/simple: simple.cpp
51 | 	$(CLANGXX) $(CXXFLAGS) $^ -o $@
52 | 
53 | $(BUILDDIR)/exceptions1: exceptions1.cpp
54 | 	$(CLANGXX) $(CXXFLAGS) $^ -o $@
55 | 
56 | # The following rules split the Clang+LLVM compilation process to discrete
57 | # parts, generating an intermediate LLVM bitcode file and performing the backend
58 | # compilation separately with llc.
59 | $(BUILDDIR)/simple-from-bitcode.bc: simple.cpp
60 | 	$(call colorecho,"Compiling C++ to LLVM bitcode")
61 | 	$(CLANGXX) $(CXXFLAGS) $^ -o $@ -c -emit-llvm
62 | 
63 | $(BUILDDIR)/simple-from-bitcode.o: $(BUILDDIR)/simple-from-bitcode.bc
64 | 	$(call colorecho,"Emitting native object file from LLVM bitcode")
65 | 	$(LLC) $^ -o $@ -filetype=obj
66 | 
67 | $(BUILDDIR)/simple-from-bitcode: $(BUILDDIR)/simple-from-bitcode.o
68 | 	$(call colorecho,"Linking with" $(LD))
69 | 	$(LD) $^ -o $@
70 | 
71 | # The following rules compile a library "memcaller" to bitcode, as well as a
72 | # "main" object that invokes it. It then uses llvm-link to link the two bitcodes
73 | # into one and proceeds with llc to compile them to native code.
74 | $(BUILDDIR)/memmain.bc: memmain.c
75 | 	$(CLANG) $(CFLAGS) $^ -o $@ -c -emit-llvm
76 | 
77 | $(BUILDDIR)/memcaller.bc: memcaller.c
78 | 	$(CLANG) $(CFLAGS) $^ -o $@ -c -emit-llvm
79 | 
80 | $(BUILDDIR)/memmain_exe.bc: $(BUILDDIR)/memmain.bc $(BUILDDIR)/memcaller.bc
81 | 	$(LLVMLINK) -o=$@ $^
82 | 
83 | $(BUILDDIR)/memmain_exe: $(BUILDDIR)/memmain_exe.bc
84 | 	$(LLC) $^ -o $(BUILDDIR)/memmain_exe.o -filetype=obj
85 | 	$(LD) $(BUILDDIR)/memmain_exe.o -o $@
86 | 
87 | $(BUILDDIR)/cxx11-range-sample: cxx11-range-sample.cpp
88 | 	$(CLANGXX) $(CXXFLAGS) $(CXX11FLAG) $^ -o $@
89 | 
90 | # Not adding this one to 'all' because it generates warnings
91 | $(BUILDDIR)/warn_in_macro: warn_in_macro.cpp
92 | 	$(CLANGXX) $(CXXFLAGS) $^ -o $@
93 | 
94 | clean:
95 | 	rm -rf $(BUILDDIR)/* *.dot test/*.pyc test/__pycache__
96 | 


--------------------------------------------------------------------------------
/test/tools.py:
--------------------------------------------------------------------------------
 1 | import difflib
 2 | import os
 3 | import subprocess
 4 | import unittest
 5 | 
 6 | 
 7 | def run_exe(exe_path, args):
 8 |     """ Runs the given executable as a subprocess, given the
 9 |         list of arguments. Captures its return code (rc) and stdout and
10 |         returns a pair: rc, stdout_str
11 |     """
12 |     popen_cmd = [exe_path] + args
13 |     proc = subprocess.Popen(popen_cmd, stdout=subprocess.PIPE,
14 |                                        stderr=subprocess.PIPE)
15 |     proc_stdout, _ = proc.communicate()
16 |     return proc.returncode, proc_stdout
17 | 
18 | 
19 | def normalized_lines(text):
20 |     return [line.strip() for line in text.splitlines()]
21 | 
22 | 
23 | class SamplesTestCase(unittest.TestCase):
24 |     def setUp(self):
25 |         # Assumes it's run from the main directory, so it can find the
26 |         # build and inputs directories as expected.
27 |         self.build_dir = 'build'
28 |         self.inputs_dir = 'inputs'
29 | 
30 |         # Check for a file that was placed by make to tell us where to find the
31 |         # LLVM binaries.
32 |         build_config_path = os.path.join(self.build_dir, '_build_config')
33 |         if not os.path.exists(build_config_path):
34 |             raise RuntimeError('Unable to find "%s"' % build_config_path)
35 |         with open(build_config_path) as f:
36 |             self.llvm_bin_path = f.readline().strip()
37 | 
38 |     def _compare_output(self, expected_out, actual_out, command=''):
39 |         expected_lines = normalized_lines(expected_out)
40 |         actual_lines = normalized_lines(actual_out)
41 | 
42 |         if expected_lines != actual_lines:
43 |             print('\n!!!!!!!! %s\nDelta (actual vs. expected):' % command)
44 |             delta = difflib.Differ().compare(expected_lines, actual_lines)
45 |             print('\n'.join(delta))
46 |             self.fail('Comparison failed. See delta above ^^^')
47 | 
48 |     def assertSampleOutput(self, cmd, input, expected_out):
49 |         """ cmd: a list [sample_name, arg1, arg2...] - the name of the sample
50 |                  to run, with additional arguments that will be added before
51 |                  the path to the input file.
52 |             input: name of a file from the input dir
53 |             expected_out: expected output as a string
54 |         """
55 |         sample_path = os.path.join(self.build_dir, cmd[0])
56 |         input_path = os.path.join(self.inputs_dir, input)
57 |         rc, stdout = run_exe(sample_path, cmd[1:] + [input_path])
58 |         stdout = stdout.decode('utf-8')
59 |         self.assertEqual(rc, 0)
60 |         self._compare_output(expected_out, stdout,
61 |             command='{} {}'.format(cmd, input))
62 | 
63 |     def assertOptPluginOutput(self, plugin, optargs, input, expected_out):
64 |         opt_path = os.path.join(self.llvm_bin_path, 'opt')
65 |         input_path = os.path.join(self.inputs_dir, input)
66 |         plugin = os.path.join(self.build_dir, plugin)
67 |         optargs = ['-load', plugin, '--disable-output'] + optargs + [input_path]
68 |         print(opt_path, optargs)
69 |         rc, stdout = run_exe(opt_path, optargs)
70 |         stdout = stdout.decode('utf-8')
71 |         self.assertEqual(rc, 0)
72 |         self._compare_output(expected_out, stdout,
73 |             command=optargs)
74 | 
75 |     def assertClangToolOutput(self, cmd, input, expected_out):
76 |         sample_path = os.path.join(self.build_dir, cmd[0])
77 |         input_path = os.path.join(self.inputs_dir, input)
78 |         rc, stdout = run_exe(sample_path, cmd[1:] + [input_path] + ['--'])
79 |         stdout = stdout.decode('utf-8')
80 |         self.assertEqual(rc, 0)
81 |         self._compare_output(expected_out, stdout,
82 |             command='{} {}'.format(cmd, input))
83 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
 1 | **Note (Sep-18-2018)**: this repository is now unmaintained. Keeping
 2 | out-of-source samples working with LLVM & Clang is tricky because of the
 3 | continuously changing build requirements. I have been working on other stuff
 4 | recently and haven't had the time and stamina to keep up-to-date.
 5 | 
 6 | I may take maintainership up again in the future.
 7 | 
 8 | .. image:: https://raw.github.com/eliben/llvm-clang-samples/master/stop.jpg
 9 |   :align: center
10 | 
11 | LLVM & Clang library usage samples
12 | ==================================
13 | 
14 | A collection of samples for using LLVM and Clang as libraries.
15 | 
16 | Branches
17 | --------
18 | 
19 | LLVM & Clang evolve rapidly and the C++ API is not stable. This means that code
20 | that links against LLVM & Clang as libraries in version X may very well not
21 | compile or work in version X+1.
22 | 
23 | Therefore, this repository has branches that track LLVM versions. For example,
24 | in branch ``llvm4.0`` the code should compile and work when linked against the
25 | released LLVM 4.0; The code in the ``master`` branch attempts to track the
26 | upstream trunk, but may sometimes lag behind. Also, note that as more samples
27 | are added I'll usually add them to ``master`` and will not backport them to
28 | older branches.
29 | 
30 | In any case, if anything doesn't compile as you'd expect it to, please open
31 | an issue.
32 | 
33 | Last known LLVM build revision for the master branch
34 | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
35 | 
36 | The last upstream LLVM revision I've successfully built the ``master`` branch
37 | against is r332892 (21-May-2018). It may build with newer revisions, or it may
38 | not. If you know it builds successfully with a newer one, please let me know and
39 | I'll update this note.
40 | 
41 | What is where
42 | -------------
43 | 
44 | src_llvm/
45 |     Source code for LLVM-based samples. These typically only require LLVM
46 |     to compile and link.
47 | 
48 | src_clang/
49 |     Source code for Clang-based samples. These require both LLVM and Clang.
50 | 
51 | using_clang_toolchain/
52 |     Some samples of using Clang as a compilation toolchain for C and C++.
53 | 
54 | inputs/
55 |     Some input files for the samples and tests.
56 | 
57 | test/
58 |     Tests for the samples.
59 | 
60 | Building the samples
61 | --------------------
62 | 
63 | A complete ``Makefile`` for Linux is included in the repository. Read the
64 | documentation at its top; it explains how to configure the build to find your
65 | local LLVM & Clang installation/build. A helper shell script named
66 | ``build_vs_released_binary.sh`` can make the build easier if you just point it
67 | to a directory when you've untarred a binary rlease.
68 | 
69 | Note that LLVM & Clang use modern C++11 constructs and require a fairly
70 | up-to-date compiler and standard C++ library to build.
71 | `This blog post <http://eli.thegreenplace.net/2014/01/16/building-gcc-4-8-from-source-on-ubunu-12-04/>`_
72 | may be useful if you don't have a modern C++ compiler on your machine.
73 | 
74 | Running tests and tools
75 | -----------------------
76 | 
77 | Note: This is not really necessary to study the examples. The tests allow me to
78 | make sure the examples keep working as LLVM advances.
79 | 
80 | For running the tests and auxiliary tools (and any other Python scripts in this
81 | repo), Python 3 is required (I tested with 3.3+). Once the samples are built
82 | with 'make', just run::
83 | 
84 |   make test
85 | 
86 | Note that it expects to find binaries from the LLVM directory with which the
87 | samples were built and linked. Look at the ``emit_build_config`` rule in the
88 | Makefile for more information.
89 | 
90 | License
91 | -------
92 | 
93 | Unless stated otherwise, all the code in this repository is in the public
94 | domain. See the ``LICENSE`` file for more details. Some source files were taken
95 | almost verbatim from LLVM/Clang; for these, the LLVM license header comment is
96 | retained and LLVM's license applies (please see ``LICENSE.txt`` in the LLVM
97 | source tree).
98 | 


--------------------------------------------------------------------------------
/inputs/simpleswitch.ll:
--------------------------------------------------------------------------------
 1 | ; ModuleID = 'inputs/simpleswitch.c'
 2 | source_filename = "inputs/simpleswitch.c"
 3 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 4 | target triple = "x86_64-unknown-linux-gnu"
 5 | 
 6 | ; Function Attrs: noinline nounwind
 7 | define i32 @decide(i8 zeroext %pred, i32* %a) #0 {
 8 |   %retval = alloca i32, align 4
 9 |   %pred.addr = alloca i8, align 1
10 |   %a.addr = alloca i32*, align 8
11 |   store i8 %pred, i8* %pred.addr, align 1
12 |   store i32* %a, i32** %a.addr, align 8
13 |   %1 = load i8, i8* %pred.addr, align 1
14 |   %conv = zext i8 %1 to i32
15 |   %2 = load i32*, i32** %a.addr, align 8
16 |   %arrayidx = getelementptr inbounds i32, i32* %2, i64 2
17 |   %3 = load i32, i32* %arrayidx, align 4
18 |   %cmp = icmp ugt i32 %conv, %3
19 |   br i1 %cmp, label %4, label %7
20 | 
21 | ; <label>:4:                                      ; preds = %0
22 |   %5 = load i32*, i32** %a.addr, align 8
23 |   %arrayidx2 = getelementptr inbounds i32, i32* %5, i64 3
24 |   %6 = load i32, i32* %arrayidx2, align 4
25 |   store i32 %6, i32* %retval, align 4
26 |   br label %30
27 | 
28 | ; <label>:7:                                      ; preds = %0
29 |   %8 = load i8, i8* %pred.addr, align 1
30 |   %conv3 = zext i8 %8 to i32
31 |   switch i32 %conv3, label %24 [
32 |     i32 1, label %9
33 |     i32 2, label %14
34 |     i32 200, label %19
35 |   ]
36 | 
37 | ; <label>:9:                                      ; preds = %7
38 |   %10 = load i32*, i32** %a.addr, align 8
39 |   %arrayidx4 = getelementptr inbounds i32, i32* %10, i64 0
40 |   %11 = load i32, i32* %arrayidx4, align 4
41 |   %12 = load i32*, i32** %a.addr, align 8
42 |   %arrayidx5 = getelementptr inbounds i32, i32* %12, i64 2
43 |   %13 = load i32, i32* %arrayidx5, align 4
44 |   %add = add i32 %11, %13
45 |   store i32 %add, i32* %retval, align 4
46 |   br label %30
47 | 
48 | ; <label>:14:                                     ; preds = %7
49 |   %15 = load i32*, i32** %a.addr, align 8
50 |   %arrayidx6 = getelementptr inbounds i32, i32* %15, i64 3
51 |   %16 = load i32, i32* %arrayidx6, align 4
52 |   %17 = load i32*, i32** %a.addr, align 8
53 |   %arrayidx7 = getelementptr inbounds i32, i32* %17, i64 4
54 |   %18 = load i32, i32* %arrayidx7, align 4
55 |   %sub = sub i32 %16, %18
56 |   store i32 %sub, i32* %retval, align 4
57 |   br label %30
58 | 
59 | ; <label>:19:                                     ; preds = %7
60 |   %20 = load i32*, i32** %a.addr, align 8
61 |   %arrayidx8 = getelementptr inbounds i32, i32* %20, i64 5
62 |   %21 = load i32, i32* %arrayidx8, align 4
63 |   %22 = load i32*, i32** %a.addr, align 8
64 |   %arrayidx9 = getelementptr inbounds i32, i32* %22, i64 6
65 |   %23 = load i32, i32* %arrayidx9, align 4
66 |   %mul = mul i32 %21, %23
67 |   store i32 %mul, i32* %retval, align 4
68 |   br label %30
69 | 
70 | ; <label>:24:                                     ; preds = %7
71 |   br label %25
72 | 
73 | ; <label>:25:                                     ; preds = %24
74 |   %26 = load i32*, i32** %a.addr, align 8
75 |   %arrayidx10 = getelementptr inbounds i32, i32* %26, i64 9
76 |   %27 = load i32, i32* %arrayidx10, align 4
77 |   %28 = load i32*, i32** %a.addr, align 8
78 |   %arrayidx11 = getelementptr inbounds i32, i32* %28, i64 4
79 |   %29 = load i32, i32* %arrayidx11, align 4
80 |   %mul12 = mul i32 %27, %29
81 |   store i32 %mul12, i32* %retval, align 4
82 |   br label %30
83 | 
84 | ; <label>:30:                                     ; preds = %25, %19, %14, %9, %4
85 |   %31 = load i32, i32* %retval, align 4
86 |   ret i32 %31
87 | }
88 | 
89 | attributes #0 = { noinline nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
90 | 
91 | !llvm.ident = !{!0}
92 | 
93 | !0 = !{!"clang version 5.0.0 (trunk 295993)"}
94 | 


--------------------------------------------------------------------------------
/src_clang/experimental/apply_replacements_with_rewriter.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // Using AST matchers with RefactoringTool. Demonstrates:
  3 | //
  4 | // * How to use Replacements to collect replacements in a matcher instead of
  5 | //   directly applying fixes to a Rewriter.
  6 | //
  7 | // Eli Bendersky (eliben@gmail.com)
  8 | // This code is in the public domain
  9 | //------------------------------------------------------------------------------
 10 | #include <string>
 11 | 
 12 | #include "clang/AST/AST.h"
 13 | #include "clang/ASTMatchers/ASTMatchFinder.h"
 14 | #include "clang/ASTMatchers/ASTMatchers.h"
 15 | #include "clang/Basic/DiagnosticOptions.h"
 16 | #include "clang/Basic/FileManager.h"
 17 | #include "clang/Basic/SourceManager.h"
 18 | #include "clang/Frontend/CompilerInstance.h"
 19 | #include "clang/Frontend/FrontendActions.h"
 20 | #include "clang/Frontend/TextDiagnosticPrinter.h"
 21 | #include "clang/Rewrite/Core/Rewriter.h"
 22 | #include "clang/Tooling/CommonOptionsParser.h"
 23 | #include "clang/Tooling/Refactoring.h"
 24 | #include "clang/Tooling/Tooling.h"
 25 | #include "llvm/Support/raw_ostream.h"
 26 | 
 27 | using namespace clang;
 28 | using namespace clang::ast_matchers;
 29 | using namespace clang::driver;
 30 | using namespace clang::tooling;
 31 | 
 32 | static llvm::cl::OptionCategory ToolingSampleCategory("Tooling Sample");
 33 | 
 34 | class IfStmtHandler : public MatchFinder::MatchCallback {
 35 | public:
 36 |   IfStmtHandler(Replacements *Replace) : Replace(Replace) {}
 37 | 
 38 |   virtual void run(const MatchFinder::MatchResult &Result) {
 39 |     // The matched 'if' statement was bound to 'ifStmt'.
 40 |     if (const IfStmt *IfS = Result.Nodes.getNodeAs<clang::IfStmt>("ifStmt")) {
 41 |       const Stmt *Then = IfS->getThen();
 42 |       Replacement Rep(*(Result.SourceManager), Then->getLocStart(), 0,
 43 |                       "// the 'if' part\n");
 44 |       Replace->insert(Rep);
 45 | 
 46 |       if (const Stmt *Else = IfS->getElse()) {
 47 |         Replacement Rep(*(Result.SourceManager), Else->getLocStart(), 0,
 48 |                         "// the 'else' part\n");
 49 |         Replace->insert(Rep);
 50 |       }
 51 |     }
 52 |   }
 53 | 
 54 | private:
 55 |   Replacements *Replace;
 56 | };
 57 | 
 58 | int main(int argc, const char **argv) {
 59 |   CommonOptionsParser op(argc, argv, ToolingSampleCategory);
 60 |   RefactoringTool Tool(op.getCompilations(), op.getSourcePathList());
 61 | 
 62 |   // Set up AST matcher callbacks.
 63 |   IfStmtHandler HandlerForIf(&Tool.getReplacements());
 64 | 
 65 |   MatchFinder Finder;
 66 |   Finder.addMatcher(ifStmt().bind("ifStmt"), &HandlerForIf);
 67 | 
 68 |   // Run the tool and collect a list of replacements. We could call runAndSave,
 69 |   // which would destructively overwrite the files with their new contents.
 70 |   // However, for demonstration purposes it's interesting to print out the
 71 |   // would-be contents of the rewritten files instead of actually rewriting
 72 |   // them.
 73 |   if (int Result = Tool.run(newFrontendActionFactory(&Finder).get())) {
 74 |     return Result;
 75 |   }
 76 | 
 77 |   // We need a SourceManager to set up the Rewriter.
 78 |   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
 79 |   DiagnosticsEngine Diagnostics(
 80 |       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
 81 |       new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts), true);
 82 |   SourceManager Sources(Diagnostics, Tool.getFiles());
 83 | 
 84 |   // Apply all replacements to a rewriter.
 85 |   Rewriter Rewrite(Sources, LangOptions());
 86 |   Tool.applyAllReplacements(Rewrite);
 87 | 
 88 |   // Query the rewriter for all the files it has rewritten, dumping their new
 89 |   // contents to stdout.
 90 |   for (Rewriter::buffer_iterator I = Rewrite.buffer_begin(),
 91 |                                  E = Rewrite.buffer_end();
 92 |        I != E; ++I) {
 93 |     const FileEntry *Entry = Sources.getFileEntryForID(I->first);
 94 |     llvm::outs() << "Rewrite buffer for file: " << Entry->getName() << "\n";
 95 |     I->second.write(llvm::outs());
 96 |   }
 97 | 
 98 |   return 0;
 99 | }
100 | 


--------------------------------------------------------------------------------
/src_clang/matchers_rewriter.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // AST matching sample. Demonstrates:
  3 | //
  4 | // * How to write a simple source tool using libTooling.
  5 | // * How to use AST matchers to find interesting AST nodes.
  6 | // * How to use the Rewriter API to rewrite the source code.
  7 | //
  8 | // Eli Bendersky (eliben@gmail.com)
  9 | // This code is in the public domain
 10 | //------------------------------------------------------------------------------
 11 | #include <string>
 12 | 
 13 | #include "clang/AST/AST.h"
 14 | #include "clang/AST/ASTConsumer.h"
 15 | #include "clang/ASTMatchers/ASTMatchFinder.h"
 16 | #include "clang/ASTMatchers/ASTMatchers.h"
 17 | #include "clang/Frontend/CompilerInstance.h"
 18 | #include "clang/Frontend/FrontendActions.h"
 19 | #include "clang/Rewrite/Core/Rewriter.h"
 20 | #include "clang/Tooling/CommonOptionsParser.h"
 21 | #include "clang/Tooling/Tooling.h"
 22 | #include "llvm/Support/raw_ostream.h"
 23 | 
 24 | using namespace clang;
 25 | using namespace clang::ast_matchers;
 26 | using namespace clang::driver;
 27 | using namespace clang::tooling;
 28 | 
 29 | static llvm::cl::OptionCategory MatcherSampleCategory("Matcher Sample");
 30 | 
 31 | class IfStmtHandler : public MatchFinder::MatchCallback {
 32 | public:
 33 |   IfStmtHandler(Rewriter &Rewrite) : Rewrite(Rewrite) {}
 34 | 
 35 |   virtual void run(const MatchFinder::MatchResult &Result) {
 36 |     // The matched 'if' statement was bound to 'ifStmt'.
 37 |     if (const IfStmt *IfS = Result.Nodes.getNodeAs<clang::IfStmt>("ifStmt")) {
 38 |       const Stmt *Then = IfS->getThen();
 39 |       Rewrite.InsertText(Then->getLocStart(), "// the 'if' part\n", true, true);
 40 | 
 41 |       if (const Stmt *Else = IfS->getElse()) {
 42 |         Rewrite.InsertText(Else->getLocStart(), "// the 'else' part\n", true,
 43 |                            true);
 44 |       }
 45 |     }
 46 |   }
 47 | 
 48 | private:
 49 |   Rewriter &Rewrite;
 50 | };
 51 | 
 52 | class IncrementForLoopHandler : public MatchFinder::MatchCallback {
 53 | public:
 54 |   IncrementForLoopHandler(Rewriter &Rewrite) : Rewrite(Rewrite) {}
 55 | 
 56 |   virtual void run(const MatchFinder::MatchResult &Result) {
 57 |     const VarDecl *IncVar = Result.Nodes.getNodeAs<VarDecl>("incVarName");
 58 |     Rewrite.InsertText(IncVar->getLocStart(), "/* increment */", true, true);
 59 |   }
 60 | 
 61 | private:
 62 |   Rewriter &Rewrite;
 63 | };
 64 | 
 65 | // Implementation of the ASTConsumer interface for reading an AST produced
 66 | // by the Clang parser. It registers a couple of matchers and runs them on
 67 | // the AST.
 68 | class MyASTConsumer : public ASTConsumer {
 69 | public:
 70 |   MyASTConsumer(Rewriter &R) : HandlerForIf(R), HandlerForFor(R) {
 71 |     // Add a simple matcher for finding 'if' statements.
 72 |     Matcher.addMatcher(ifStmt().bind("ifStmt"), &HandlerForIf);
 73 | 
 74 |     // Add a complex matcher for finding 'for' loops with an initializer set
 75 |     // to 0, < comparison in the codition and an increment. For example:
 76 |     //
 77 |     //  for (int i = 0; i < N; ++i)
 78 |     Matcher.addMatcher(
 79 |         forStmt(hasLoopInit(declStmt(hasSingleDecl(
 80 |                     varDecl(hasInitializer(integerLiteral(equals(0))))
 81 |                         .bind("initVarName")))),
 82 |                 hasIncrement(unaryOperator(
 83 |                     hasOperatorName("++"),
 84 |                     hasUnaryOperand(declRefExpr(to(
 85 |                         varDecl(hasType(isInteger())).bind("incVarName")))))),
 86 |                 hasCondition(binaryOperator(
 87 |                     hasOperatorName("<"),
 88 |                     hasLHS(ignoringParenImpCasts(declRefExpr(to(
 89 |                         varDecl(hasType(isInteger())).bind("condVarName"))))),
 90 |                     hasRHS(expr(hasType(isInteger()))))))
 91 |             .bind("forLoop"),
 92 |         &HandlerForFor);
 93 |   }
 94 | 
 95 |   void HandleTranslationUnit(ASTContext &Context) override {
 96 |     // Run the matchers when we have the whole TU parsed.
 97 |     Matcher.matchAST(Context);
 98 |   }
 99 | 
100 | private:
101 |   IfStmtHandler HandlerForIf;
102 |   IncrementForLoopHandler HandlerForFor;
103 |   MatchFinder Matcher;
104 | };
105 | 
106 | // For each source file provided to the tool, a new FrontendAction is created.
107 | class MyFrontendAction : public ASTFrontendAction {
108 | public:
109 |   MyFrontendAction() {}
110 |   void EndSourceFileAction() override {
111 |     TheRewriter.getEditBuffer(TheRewriter.getSourceMgr().getMainFileID())
112 |         .write(llvm::outs());
113 |   }
114 | 
115 |   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
116 |                                                  StringRef file) override {
117 |     TheRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
118 |     return llvm::make_unique<MyASTConsumer>(TheRewriter);
119 |   }
120 | 
121 | private:
122 |   Rewriter TheRewriter;
123 | };
124 | 
125 | int main(int argc, const char **argv) {
126 |   CommonOptionsParser op(argc, argv, MatcherSampleCategory);
127 |   ClangTool Tool(op.getCompilations(), op.getSourcePathList());
128 | 
129 |   return Tool.run(newFrontendActionFactory<MyFrontendAction>().get());
130 | }
131 | 


--------------------------------------------------------------------------------
/src_clang/tooling_sample.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // Tooling sample. Demonstrates:
  3 | //
  4 | // * How to write a simple source tool using libTooling.
  5 | // * How to use RecursiveASTVisitor to find interesting AST nodes.
  6 | // * How to use the Rewriter API to rewrite the source code.
  7 | //
  8 | // Eli Bendersky (eliben@gmail.com)
  9 | // This code is in the public domain
 10 | //------------------------------------------------------------------------------
 11 | #include <sstream>
 12 | #include <string>
 13 | 
 14 | #include "clang/AST/AST.h"
 15 | #include "clang/AST/ASTConsumer.h"
 16 | #include "clang/AST/RecursiveASTVisitor.h"
 17 | #include "clang/Frontend/ASTConsumers.h"
 18 | #include "clang/Frontend/CompilerInstance.h"
 19 | #include "clang/Frontend/FrontendActions.h"
 20 | #include "clang/Rewrite/Core/Rewriter.h"
 21 | #include "clang/Tooling/CommonOptionsParser.h"
 22 | #include "clang/Tooling/Tooling.h"
 23 | #include "llvm/Support/raw_ostream.h"
 24 | 
 25 | using namespace clang;
 26 | using namespace clang::driver;
 27 | using namespace clang::tooling;
 28 | 
 29 | static llvm::cl::OptionCategory ToolingSampleCategory("Tooling Sample");
 30 | 
 31 | // By implementing RecursiveASTVisitor, we can specify which AST nodes
 32 | // we're interested in by overriding relevant methods.
 33 | class MyASTVisitor : public RecursiveASTVisitor<MyASTVisitor> {
 34 | public:
 35 |   MyASTVisitor(Rewriter &R) : TheRewriter(R) {}
 36 | 
 37 |   bool VisitStmt(Stmt *s) {
 38 |     // Only care about If statements.
 39 |     if (isa<IfStmt>(s)) {
 40 |       IfStmt *IfStatement = cast<IfStmt>(s);
 41 |       Stmt *Then = IfStatement->getThen();
 42 | 
 43 |       TheRewriter.InsertText(Then->getLocStart(), "// the 'if' part\n", true,
 44 |                              true);
 45 | 
 46 |       Stmt *Else = IfStatement->getElse();
 47 |       if (Else)
 48 |         TheRewriter.InsertText(Else->getLocStart(), "// the 'else' part\n",
 49 |                                true, true);
 50 |     }
 51 | 
 52 |     return true;
 53 |   }
 54 | 
 55 |   bool VisitFunctionDecl(FunctionDecl *f) {
 56 |     // Only function definitions (with bodies), not declarations.
 57 |     if (f->hasBody()) {
 58 |       Stmt *FuncBody = f->getBody();
 59 | 
 60 |       // Type name as string
 61 |       QualType QT = f->getReturnType();
 62 |       std::string TypeStr = QT.getAsString();
 63 | 
 64 |       // Function name
 65 |       DeclarationName DeclName = f->getNameInfo().getName();
 66 |       std::string FuncName = DeclName.getAsString();
 67 | 
 68 |       // Add comment before
 69 |       std::stringstream SSBefore;
 70 |       SSBefore << "// Begin function " << FuncName << " returning " << TypeStr
 71 |                << "\n";
 72 |       SourceLocation ST = f->getSourceRange().getBegin();
 73 |       TheRewriter.InsertText(ST, SSBefore.str(), true, true);
 74 | 
 75 |       // And after
 76 |       std::stringstream SSAfter;
 77 |       SSAfter << "\n// End function " << FuncName;
 78 |       ST = FuncBody->getLocEnd().getLocWithOffset(1);
 79 |       TheRewriter.InsertText(ST, SSAfter.str(), true, true);
 80 |     }
 81 | 
 82 |     return true;
 83 |   }
 84 | 
 85 | private:
 86 |   Rewriter &TheRewriter;
 87 | };
 88 | 
 89 | // Implementation of the ASTConsumer interface for reading an AST produced
 90 | // by the Clang parser.
 91 | class MyASTConsumer : public ASTConsumer {
 92 | public:
 93 |   MyASTConsumer(Rewriter &R) : Visitor(R) {}
 94 | 
 95 |   // Override the method that gets called for each parsed top-level
 96 |   // declaration.
 97 |   bool HandleTopLevelDecl(DeclGroupRef DR) override {
 98 |     for (DeclGroupRef::iterator b = DR.begin(), e = DR.end(); b != e; ++b) {
 99 |       // Traverse the declaration using our AST visitor.
100 |       Visitor.TraverseDecl(*b);
101 |       (*b)->dump();
102 |     }
103 |     return true;
104 |   }
105 | 
106 | private:
107 |   MyASTVisitor Visitor;
108 | };
109 | 
110 | // For each source file provided to the tool, a new FrontendAction is created.
111 | class MyFrontendAction : public ASTFrontendAction {
112 | public:
113 |   MyFrontendAction() {}
114 |   void EndSourceFileAction() override {
115 |     SourceManager &SM = TheRewriter.getSourceMgr();
116 |     llvm::errs() << "** EndSourceFileAction for: "
117 |                  << SM.getFileEntryForID(SM.getMainFileID())->getName() << "\n";
118 | 
119 |     // Now emit the rewritten buffer.
120 |     TheRewriter.getEditBuffer(SM.getMainFileID()).write(llvm::outs());
121 |   }
122 | 
123 |   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
124 |                                                  StringRef file) override {
125 |     llvm::errs() << "** Creating AST consumer for: " << file << "\n";
126 |     TheRewriter.setSourceMgr(CI.getSourceManager(), CI.getLangOpts());
127 |     return llvm::make_unique<MyASTConsumer>(TheRewriter);
128 |   }
129 | 
130 | private:
131 |   Rewriter TheRewriter;
132 | };
133 | 
134 | int main(int argc, const char **argv) {
135 |   CommonOptionsParser op(argc, argv, ToolingSampleCategory);
136 |   ClangTool Tool(op.getCompilations(), op.getSourcePathList());
137 | 
138 |   // ClangTool::run accepts a FrontendActionFactory, which is then used to
139 |   // create new objects implementing the FrontendAction interface. Here we use
140 |   // the helper newFrontendActionFactory to create a default factory that will
141 |   // return a new MyFrontendAction object every time.
142 |   // To further customize this, we could create our own factory class.
143 |   return Tool.run(newFrontendActionFactory<MyFrontendAction>().get());
144 | }
145 | 


--------------------------------------------------------------------------------
/src_llvm/replace_threadidx_with_call.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // replace_threadidx_with_call LLVM sample. Demonstrates:
  3 | //
  4 | // * Detecting a non-trivial instruction pattern (load instruction with a
  5 | //   specific form of getelementptr constant expression address).
  6 | // * Adding new function declarations into the module.
  7 | // * Performing an IR transformation: replacing instructions by other
  8 | //   instructions.
  9 | //
 10 | // Note: this is not a complete transformation for CUDA's special globals, but
 11 | // a much simplified example.
 12 | //
 13 | // Eli Bendersky (eliben@gmail.com)
 14 | // This code is in the public domain
 15 | //------------------------------------------------------------------------------
 16 | #include "llvm/IR/Constants.h"
 17 | #include "llvm/IR/Instruction.h"
 18 | #include "llvm/IR/Instructions.h"
 19 | #include "llvm/IR/LegacyPassManager.h"
 20 | #include "llvm/IR/Module.h"
 21 | #include "llvm/IR/Operator.h"
 22 | #include "llvm/IRReader/IRReader.h"
 23 | #include "llvm/Pass.h"
 24 | #include "llvm/Support/SourceMgr.h"
 25 | #include "llvm/Support/raw_ostream.h"
 26 | #include <string>
 27 | #include <vector>
 28 | 
 29 | using namespace llvm;
 30 | 
 31 | class ReplaceThreadIdxRefs : public FunctionPass {
 32 | public:
 33 |   ReplaceThreadIdxRefs(Function *Tidx, Function *Tidy, Function *Tidz)
 34 |       : FunctionPass(ID), TidxRef(Tidx), TidyRef(Tidy), TidzRef(Tidz) {}
 35 | 
 36 |   virtual bool runOnFunction(Function &F) {
 37 |     bool Modified = false;
 38 |     for (Function::iterator I = F.begin(); I != F.end(); I++) {
 39 |       BasicBlock *BB = &*I;
 40 | 
 41 |       for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
 42 |         // Note: taking BI++ out of the for statement is important. Since this
 43 |         // loop may delete the instruction at *BI, this will invalidate the
 44 |         // iterator. So we make sure the iterator is incremented right from
 45 |         // the start and it already points to the next instruction. This way,
 46 |         // removing I from the basic block is harmless.
 47 |         Instruction &I = *BI++;
 48 | 
 49 |         // These nested conditions match a specific instruction pattern. We're
 50 |         // looking for a load whose address is a GEP constant expression.
 51 |         if (LoadInst *Load = dyn_cast<LoadInst>(&I)) {
 52 |           if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Load->getOperand(0))) {
 53 |             if (GEPOperator *GEP = dyn_cast<GEPOperator>(CE)) {
 54 |               Value *Ptr = GEP->getPointerOperand();
 55 | 
 56 |               // Only look for accesses to threadIdx with the expected amount of
 57 |               // GEP indices (essentially struct access to threadIdx.<member>.
 58 |               if (Ptr->getName() != "threadIdx" || GEP->getNumIndices() != 2) {
 59 |                 continue;
 60 |               }
 61 | 
 62 |               // struct access as a GEP has two indices; read the LLVM
 63 |               // documentation on GEPs if this doesn't make sense.
 64 |               if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(2))) {
 65 |                 // Choose a function based on the index.
 66 |                 uint64_t DimIndex = CI->getZExtValue();
 67 |                 Function *TargetFunc;
 68 |                 if (DimIndex == 0) {
 69 |                   TargetFunc = TidxRef;
 70 |                 } else if (DimIndex == 1) {
 71 |                   TargetFunc = TidyRef;
 72 |                 } else if (DimIndex == 2) {
 73 |                   TargetFunc = TidzRef;
 74 |                 } else {
 75 |                   report_fatal_error("Invalid index for threadIdx access");
 76 |                 }
 77 | 
 78 |                 // Create a call instruction to the appropriate _tid* function
 79 |                 // right before the load and replace the load by it.
 80 |                 CallInst *TidFuncCall = CallInst::Create(TargetFunc, "", Load);
 81 |                 TidFuncCall->takeName(Load);
 82 |                 Load->replaceAllUsesWith(TidFuncCall);
 83 |                 Load->eraseFromParent();
 84 |                 Modified = true;
 85 |               }
 86 |             }
 87 |           }
 88 |         }
 89 |       }
 90 |     }
 91 | 
 92 |     return Modified;
 93 |   }
 94 | 
 95 | private:
 96 |   Function *TidxRef;
 97 |   Function *TidyRef;
 98 |   Function *TidzRef;
 99 | 
100 |   // The address of this member is used to uniquely identify the class. This is
101 |   // used by LLVM's own RTTI mechanism.
102 |   static char ID;
103 | };
104 | 
105 | char ReplaceThreadIdxRefs::ID = 0;
106 | 
107 | int main(int argc, char **argv) {
108 |   if (argc < 2) {
109 |     errs() << "Usage: " << argv[0] << " <IR file>\n";
110 |     return 1;
111 |   }
112 | 
113 |   // Parse the input LLVM IR file into a module.
114 |   SMDiagnostic Err;
115 |   LLVMContext Context;
116 |   std::unique_ptr<Module> Mod(parseIRFile(argv[1], Err, Context));
117 |   if (!Mod) {
118 |     Err.print(argv[0], errs());
119 |     return 1;
120 |   }
121 | 
122 |   // Create a function declarations for _tidx, _tidy, _tidz
123 |   FunctionType *TidFuncTy =
124 |       FunctionType::get(Type::getInt32Ty(Mod->getContext()), false);
125 |   Function *Tidx = Function::Create(TidFuncTy, GlobalValue::InternalLinkage,
126 |                                     "_tidx", Mod.get());
127 |   Function *Tidy = Function::Create(TidFuncTy, GlobalValue::InternalLinkage,
128 |                                     "_tidy", Mod.get());
129 |   Function *Tidz = Function::Create(TidFuncTy, GlobalValue::InternalLinkage,
130 |                                     "_tidz", Mod.get());
131 | 
132 |   // Create a pass manager and fill it with the passes we want to run.
133 |   legacy::PassManager PM;
134 |   PM.add(new ReplaceThreadIdxRefs(Tidx, Tidy, Tidz));
135 |   PM.run(*Mod);
136 | 
137 |   outs() << "Dumping the module after the pass has run:\n";
138 |   // These dumps only work with LLVM built with a special cmake flag enabling
139 |   // dumps.
140 |   // Mod->dump();
141 | 
142 |   return 0;
143 | }
144 | 


--------------------------------------------------------------------------------
/src_clang/rewritersample.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // Clang rewriter sample. Demonstrates:
  3 | //
  4 | // * How to use RecursiveASTVisitor to find interesting AST nodes.
  5 | // * How to use the Rewriter API to rewrite the source code.
  6 | //
  7 | // Eli Bendersky (eliben@gmail.com)
  8 | // This code is in the public domain
  9 | //------------------------------------------------------------------------------
 10 | #include <cstdio>
 11 | #include <memory>
 12 | #include <sstream>
 13 | #include <string>
 14 | 
 15 | #include "clang/AST/ASTConsumer.h"
 16 | #include "clang/AST/RecursiveASTVisitor.h"
 17 | #include "clang/Basic/Diagnostic.h"
 18 | #include "clang/Basic/FileManager.h"
 19 | #include "clang/Basic/SourceManager.h"
 20 | #include "clang/Basic/TargetInfo.h"
 21 | #include "clang/Basic/TargetOptions.h"
 22 | #include "clang/Frontend/CompilerInstance.h"
 23 | #include "clang/Lex/Preprocessor.h"
 24 | #include "clang/Parse/ParseAST.h"
 25 | #include "clang/Rewrite/Core/Rewriter.h"
 26 | #include "clang/Rewrite/Frontend/Rewriters.h"
 27 | #include "llvm/Support/Host.h"
 28 | #include "llvm/Support/raw_ostream.h"
 29 | 
 30 | using namespace clang;
 31 | 
 32 | // By implementing RecursiveASTVisitor, we can specify which AST nodes
 33 | // we're interested in by overriding relevant methods.
 34 | class MyASTVisitor : public RecursiveASTVisitor<MyASTVisitor> {
 35 | public:
 36 |   MyASTVisitor(Rewriter &R) : TheRewriter(R) {}
 37 | 
 38 |   bool VisitStmt(Stmt *s) {
 39 |     // Only care about If statements.
 40 |     if (isa<IfStmt>(s)) {
 41 |       IfStmt *IfStatement = cast<IfStmt>(s);
 42 |       Stmt *Then = IfStatement->getThen();
 43 | 
 44 |       TheRewriter.InsertText(Then->getLocStart(), "// the 'if' part\n", true,
 45 |                              true);
 46 | 
 47 |       Stmt *Else = IfStatement->getElse();
 48 |       if (Else)
 49 |         TheRewriter.InsertText(Else->getLocStart(), "// the 'else' part\n",
 50 |                                true, true);
 51 |     }
 52 | 
 53 |     return true;
 54 |   }
 55 | 
 56 |   bool VisitFunctionDecl(FunctionDecl *f) {
 57 |     // Only function definitions (with bodies), not declarations.
 58 |     if (f->hasBody()) {
 59 |       Stmt *FuncBody = f->getBody();
 60 | 
 61 |       // Type name as string
 62 |       QualType QT = f->getReturnType();
 63 |       std::string TypeStr = QT.getAsString();
 64 | 
 65 |       // Function name
 66 |       DeclarationName DeclName = f->getNameInfo().getName();
 67 |       std::string FuncName = DeclName.getAsString();
 68 | 
 69 |       // Add comment before
 70 |       std::stringstream SSBefore;
 71 |       SSBefore << "// Begin function " << FuncName << " returning " << TypeStr
 72 |                << "\n";
 73 |       SourceLocation ST = f->getSourceRange().getBegin();
 74 |       TheRewriter.InsertText(ST, SSBefore.str(), true, true);
 75 | 
 76 |       // And after
 77 |       std::stringstream SSAfter;
 78 |       SSAfter << "\n// End function " << FuncName;
 79 |       ST = FuncBody->getLocEnd().getLocWithOffset(1);
 80 |       TheRewriter.InsertText(ST, SSAfter.str(), true, true);
 81 |     }
 82 | 
 83 |     return true;
 84 |   }
 85 | 
 86 | private:
 87 |   Rewriter &TheRewriter;
 88 | };
 89 | 
 90 | // Implementation of the ASTConsumer interface for reading an AST produced
 91 | // by the Clang parser.
 92 | class MyASTConsumer : public ASTConsumer {
 93 | public:
 94 |   MyASTConsumer(Rewriter &R) : Visitor(R) {}
 95 | 
 96 |   // Override the method that gets called for each parsed top-level
 97 |   // declaration.
 98 |   virtual bool HandleTopLevelDecl(DeclGroupRef DR) {
 99 |     for (DeclGroupRef::iterator b = DR.begin(), e = DR.end(); b != e; ++b)
100 |       // Traverse the declaration using our AST visitor.
101 |       Visitor.TraverseDecl(*b);
102 |     return true;
103 |   }
104 | 
105 | private:
106 |   MyASTVisitor Visitor;
107 | };
108 | 
109 | int main(int argc, char *argv[]) {
110 |   if (argc != 2) {
111 |     llvm::errs() << "Usage: rewritersample <filename>\n";
112 |     return 1;
113 |   }
114 | 
115 |   // CompilerInstance will hold the instance of the Clang compiler for us,
116 |   // managing the various objects needed to run the compiler.
117 |   CompilerInstance TheCompInst;
118 |   TheCompInst.createDiagnostics();
119 | 
120 |   LangOptions &lo = TheCompInst.getLangOpts();
121 |   lo.CPlusPlus = 1;
122 | 
123 |   // Initialize target info with the default triple for our platform.
124 |   auto TO = std::make_shared<TargetOptions>();
125 |   TO->Triple = llvm::sys::getDefaultTargetTriple();
126 |   TargetInfo *TI =
127 |       TargetInfo::CreateTargetInfo(TheCompInst.getDiagnostics(), TO);
128 |   TheCompInst.setTarget(TI);
129 | 
130 |   TheCompInst.createFileManager();
131 |   FileManager &FileMgr = TheCompInst.getFileManager();
132 |   TheCompInst.createSourceManager(FileMgr);
133 |   SourceManager &SourceMgr = TheCompInst.getSourceManager();
134 |   TheCompInst.createPreprocessor(TU_Module);
135 |   TheCompInst.createASTContext();
136 | 
137 |   // A Rewriter helps us manage the code rewriting task.
138 |   Rewriter TheRewriter;
139 |   TheRewriter.setSourceMgr(SourceMgr, TheCompInst.getLangOpts());
140 | 
141 |   // Set the main file handled by the source manager to the input file.
142 |   const FileEntry *FileIn = FileMgr.getFile(argv[1]);
143 |   SourceMgr.setMainFileID(
144 |       SourceMgr.createFileID(FileIn, SourceLocation(), SrcMgr::C_User));
145 |   TheCompInst.getDiagnosticClient().BeginSourceFile(
146 |       TheCompInst.getLangOpts(), &TheCompInst.getPreprocessor());
147 | 
148 |   // Create an AST consumer instance which is going to get called by
149 |   // ParseAST.
150 |   MyASTConsumer TheConsumer(TheRewriter);
151 | 
152 |   // Parse the file to AST, registering our consumer as the AST consumer.
153 |   ParseAST(TheCompInst.getPreprocessor(), &TheConsumer,
154 |            TheCompInst.getASTContext());
155 | 
156 |   // At this point the rewriter's buffer should be full with the rewritten
157 |   // file contents.
158 |   const RewriteBuffer *RewriteBuf =
159 |       TheRewriter.getRewriteBufferFor(SourceMgr.getMainFileID());
160 |   llvm::outs() << std::string(RewriteBuf->begin(), RewriteBuf->end());
161 | 
162 |   return 0;
163 | }
164 | 


--------------------------------------------------------------------------------
/inputs/bigfunc.c:
--------------------------------------------------------------------------------
  1 | #define N_WAVE          1024
  2 | #define LOG2_N_WAVE     10
  3 | 
  4 | typedef short fixed;
  5 | 
  6 | fixed fix_mpy(fixed a, fixed b) {
  7 |   return ((long)(a) * (long)(b))>>15;
  8 | }
  9 | 
 10 | fixed foo2(fixed a) {
 11 |   return fix_mpy(a, a * 2) + fix_mpy(a, a * 3);
 12 | }
 13 | 
 14 | void foo3(fixed* q, fixed* w, int m) {
 15 |   int i;
 16 |   for (i = 0; i < m; ++i) {
 17 |     for (int j = 0; j < i; ++j) {
 18 |       for (int k = 0; k < j; ++k) {
 19 |         q[i] = m * w[j] + q[i-2];
 20 |         q[k + 1] = w[j];
 21 |       }
 22 |     }
 23 |   }
 24 | }
 25 | 
 26 | int fix_fft(fixed fr[], fixed fi[], fixed* Sinewave, int m, int inverse)
 27 | {
 28 |   int mr,nn,i,j,l,k,istep, n, scale, shift;
 29 |   fixed qr,qi,tr,ti,wr,wi,t;
 30 | 
 31 |     n = 1<<m;
 32 | 
 33 |   if(n > N_WAVE)
 34 |     return -1;
 35 | 
 36 |   mr = 0;
 37 |   nn = n - 1;
 38 |   scale = 0;
 39 | 
 40 |   foo3(fr, fi, m);
 41 | 
 42 |   for(m=1; m<=nn; ++m) {
 43 |     l = n;
 44 |     do {
 45 |       l >>= 1;
 46 |     } while(mr+l > nn);
 47 |     mr = foo2((mr & (l-1)) + l);
 48 | 
 49 |     if(mr <= m) continue;
 50 |     tr = fr[m];
 51 |     fr[m] = fr[mr];
 52 |     fr[mr] = tr;
 53 |     ti = fi[m];
 54 |     fi[m] = fi[mr];
 55 |     fi[mr] = ti;
 56 |   }
 57 | 
 58 |   foo3(fr, fi, m);
 59 |   foo3(fr, Sinewave, m);
 60 |   foo3(fr, fi, m);
 61 |   foo3(fr, Sinewave, m);
 62 |   foo3(fr, fi, m);
 63 |   foo3(fr, Sinewave, m);
 64 |   foo3(fr, fi, m);
 65 |   foo3(fr, Sinewave, m);
 66 |   foo3(fr, fi, m);
 67 |   foo3(fr, Sinewave, m);
 68 |   foo3(fr, fi, m);
 69 |   foo3(fr, Sinewave, m);
 70 |   foo3(fr, fi, m);
 71 |   foo3(fr, fi, m);
 72 |   foo3(fr, fi, m);
 73 |   foo3(fr, fi, m);
 74 |   foo3(fr, fi, m);
 75 |   foo3(fr, fi, m);
 76 |   foo3(fr, fi, m);
 77 |   foo3(fr, Sinewave, m);
 78 |   foo3(fr, fi, m);
 79 |   foo3(fr, Sinewave, m);
 80 |   foo3(fr, fi, m);
 81 |   foo3(fr, Sinewave, m);
 82 |   foo3(fr, fi, m);
 83 |   foo3(fr, Sinewave, m);
 84 |   foo3(fr, fi, m);
 85 |   foo3(fr, Sinewave, m);
 86 |   foo3(fr, fi, m);
 87 |   foo3(fr, Sinewave, m);
 88 |   foo3(fr, Sinewave, m);
 89 |   foo3(fr, fi, m);
 90 |   foo3(fr, Sinewave, m);
 91 |   foo3(fr, fi, m);
 92 |   foo3(fr, Sinewave, m);
 93 |   foo3(fr, fi, m);
 94 |   foo3(fr, Sinewave, m);
 95 |   foo3(fr, fi, m);
 96 |   foo3(fr, Sinewave, m);
 97 |   foo3(fr, fi, m);
 98 |   foo3(fr, Sinewave, m);
 99 |   foo3(fr, Sinewave, m);
100 |   foo3(fr, fi, m);
101 |   foo3(fr, Sinewave, m);
102 |   foo3(fr, fi, m);
103 |   foo3(fr, Sinewave, m);
104 |   foo3(fr, fi, m);
105 |   foo3(fr, Sinewave, m);
106 |   foo3(fr, fi, m);
107 |   foo3(fr, Sinewave, m);
108 |   foo3(fr, fi, m);
109 |   foo3(fr, Sinewave, m);
110 |   foo3(fr, Sinewave, m);
111 |   foo3(fr, fi, m);
112 |   foo3(fr, Sinewave, m);
113 |   foo3(fr, fi, m);
114 |   foo3(fr, Sinewave, m);
115 |   foo3(fr, fi, m);
116 |   foo3(fr, Sinewave, m);
117 |   foo3(fr, fi, m);
118 |   foo3(fr, Sinewave, m);
119 |   foo3(fr, fi, m);
120 |   foo3(fr, Sinewave, m);
121 |   foo3(fr, Sinewave, m);
122 |   foo3(fr, fi, m);
123 |   foo3(fr, Sinewave, m);
124 |   foo3(fr, fi, m);
125 |   foo3(fr, Sinewave, m);
126 |   foo3(fr, fi, m);
127 |   foo3(fr, Sinewave, m);
128 |   foo3(fr, fi, m);
129 |   foo3(fr, Sinewave, m);
130 |   foo3(fr, fi, m);
131 |   foo3(fr, Sinewave, m);
132 |   foo3(fr, Sinewave, m);
133 |   foo3(fr, fi, m);
134 |   foo3(fr, Sinewave, m);
135 |   foo3(fr, fi, m);
136 |   foo3(fr, Sinewave, m);
137 |   foo3(fr, fi, m);
138 |   foo3(fr, Sinewave, m);
139 |   foo3(fr, fi, m);
140 |   foo3(fr, Sinewave, m);
141 |   foo3(fr, fi, m);
142 |   foo3(fr, Sinewave, m);
143 |   foo3(fr, Sinewave, m);
144 |   foo3(fr, fi, m);
145 |   foo3(fr, Sinewave, m);
146 |   foo3(fr, fi, m);
147 |   foo3(fr, Sinewave, m);
148 |   foo3(fr, fi, m);
149 |   foo3(fr, Sinewave, m);
150 |   foo3(fr, fi, m);
151 |   foo3(fr, Sinewave, m);
152 |   foo3(fr, fi, m);
153 |   foo3(fr, Sinewave, m);
154 |   l = 1;
155 |   k = LOG2_N_WAVE-1;
156 |   while(l < n) {
157 |     if(inverse) {
158 | 
159 |       shift = 0;
160 |       for(i=0; i<n; ++i) {
161 |         foo3(fr, fi, m);
162 |         foo3(fr, Sinewave, m);
163 |         j = fr[i];
164 |         if(j < 0)
165 |           j = -j;
166 |         m = fi[i];
167 |         if(m < 0)
168 |           m = -m;
169 |         if(j > 16383 || m > 16383) {
170 |           shift = 1;
171 |           break;
172 |         }
173 |       }
174 |       if(shift)
175 |         ++scale;
176 |     } else {
177 | 
178 |       shift = 1;
179 |     }
180 |     istep = l << 1;
181 |     for(m=0; m<l; ++m) {
182 |       j = m << k;
183 | 
184 |       wr =  Sinewave[j+N_WAVE/4];
185 |       wi = -Sinewave[j];
186 |       if(inverse)
187 |         wi = -wi;
188 |       if(shift) {
189 |         foo3(fr, fi, m);
190 |         foo3(fr, Sinewave, m);
191 |         wr >>= 1;
192 |         wi >>= 1;
193 |       }
194 |       for(i=m; i<n; i+=istep) {
195 |         j = i + l;
196 |           tr = fix_mpy(wr,fr[j]) - fix_mpy(wi,fi[j]);
197 |           ti = fix_mpy(wr,fi[j]) + fix_mpy(wi,fr[j]);
198 |         foo3(fr, fi, m);
199 |         foo3(fr, Sinewave, m);
200 |         foo3(fr, fi, m);
201 |         foo3(fr, fi, m);
202 |         foo3(fr, fi, m);
203 |         foo3(fr, Sinewave, m);
204 |         foo3(fr, Sinewave, m);
205 |         foo3(fr, Sinewave, m);
206 |         foo3(fr, fi, m);
207 |         foo3(fr, fi, m);
208 |         foo3(fr, fi, m);
209 |         foo3(fr, Sinewave, m);
210 |         foo3(fr, fi, m);
211 |         foo3(fr, fi, m);
212 |         foo3(fr, fi, m);
213 |         foo3(fr, Sinewave, m);
214 |         foo3(fr, Sinewave, m);
215 |         foo3(fr, Sinewave, m);
216 |         foo3(fr, Sinewave, m);
217 |         foo3(fr, fi, m);
218 |         foo3(fr, fi, m);
219 |         foo3(fr, fi, m);
220 |         foo3(fr, Sinewave, m);
221 |         foo3(fr, Sinewave, m);
222 |         foo3(fr, Sinewave, m);
223 |         foo3(fr, Sinewave, m);
224 |         foo3(fr, fi, m);
225 |         foo3(fr, fi, m);
226 |         foo3(fr, fi, m);
227 |         foo3(fr, Sinewave, m);
228 |         foo3(fr, Sinewave, m);
229 |         foo3(fr, Sinewave, m);
230 |         qr = fr[i];
231 |         qi = fi[i];
232 |         if(shift) {
233 |           qr >>= 1;
234 |           qi >>= 1;
235 |         }
236 |         fr[j] = qr - tr;
237 |         fi[j] = qi - ti;
238 |         fr[i] = qr + tr;
239 |         fi[i] = qi + ti;
240 |       }
241 |     }
242 |     --k;
243 |     l = istep;
244 |   }
245 | 
246 |   return scale;
247 | }
248 | 


--------------------------------------------------------------------------------
/src_llvm/bb_toposort_sccs.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // bb_toposort_sccs LLVM sample. Demonstrates:
  3 | //
  4 | // * How to implement DFS & topological sort over the control-flow graph (CFG)
  5 | //   of a function.
  6 | // * How to use po_iterator for post-order iteration over basic blocks.
  7 | // * How to use scc_iterator for post-order iteration over strongly-connected
  8 | //   components in the graph of basic blocks.
  9 | //
 10 | // Eli Bendersky (eliben@gmail.com)
 11 | // This code is in the public domain
 12 | //------------------------------------------------------------------------------
 13 | #include "llvm/ADT/DenseMap.h"
 14 | #include "llvm/ADT/PostOrderIterator.h"
 15 | #include "llvm/ADT/SCCIterator.h"
 16 | #include "llvm/IR/CFG.h"
 17 | #include "llvm/IR/DataLayout.h"
 18 | #include "llvm/IR/Instruction.h"
 19 | #include "llvm/IR/Instructions.h"
 20 | #include "llvm/IR/LegacyPassManager.h"
 21 | #include "llvm/IR/Module.h"
 22 | #include "llvm/IRReader/IRReader.h"
 23 | #include "llvm/Pass.h"
 24 | #include "llvm/Support/SourceMgr.h"
 25 | #include "llvm/Support/raw_ostream.h"
 26 | #include <string>
 27 | #include <vector>
 28 | 
 29 | using namespace llvm;
 30 | 
 31 | // Runs a topological sort on the basic blocks of the given function. Uses
 32 | // the simple recursive DFS from "Introduction to algorithms", with 3-coloring
 33 | // of vertices. The coloring enables detecting cycles in the graph with a simple
 34 | // test.
 35 | class TopoSorter {
 36 | public:
 37 |   void runToposort(const Function &F) {
 38 |     outs() << "Topological sort of " << F.getName() << ":\n";
 39 |     // Initialize the color map by marking all the vertices white.
 40 |     for (Function::const_iterator I = F.begin(), IE = F.end(); I != IE; ++I) {
 41 |       ColorMap[&*I] = TopoSorter::WHITE;
 42 |     }
 43 | 
 44 |     // The BB graph has a single entry vertex from which the other BBs should
 45 |     // be discoverable - the function entry block.
 46 |     bool success = recursiveDFSToposort(&F.getEntryBlock());
 47 |     if (success) {
 48 |       // Now we have all the BBs inside SortedBBs in reverse topological order.
 49 |       for (BBVector::const_reverse_iterator RI = SortedBBs.rbegin(),
 50 |                                             RE = SortedBBs.rend();
 51 |            RI != RE; ++RI) {
 52 |         outs() << "  " << (*RI)->getName() << "\n";
 53 |       }
 54 |     } else {
 55 |       outs() << "  Sorting failed\n";
 56 |     }
 57 |   }
 58 | 
 59 | private:
 60 |   enum Color { WHITE, GREY, BLACK };
 61 |   // Color marks per vertex (BB).
 62 |   typedef DenseMap<const BasicBlock *, Color> BBColorMap;
 63 |   // Collects vertices (BBs) in "finish" order. The first finished vertex is
 64 |   // first, and so on.
 65 |   typedef SmallVector<const BasicBlock *, 32> BBVector;
 66 |   BBColorMap ColorMap;
 67 |   BBVector SortedBBs;
 68 | 
 69 |   // Helper function to recursively run topological sort from a given BB.
 70 |   // Returns true if the sort succeeded and false otherwise; topological sort
 71 |   // may fail if, for example, the graph is not a DAG (detected a cycle).
 72 |   bool recursiveDFSToposort(const BasicBlock *BB) {
 73 |     ColorMap[BB] = TopoSorter::GREY;
 74 |     // For demonstration, using the lowest-level APIs here. A BB's successors
 75 |     // are determined by looking at its terminator instruction.
 76 |     const TerminatorInst *TInst = BB->getTerminator();
 77 |     for (unsigned I = 0, NSucc = TInst->getNumSuccessors(); I < NSucc; ++I) {
 78 |       BasicBlock *Succ = TInst->getSuccessor(I);
 79 |       Color SuccColor = ColorMap[Succ];
 80 |       if (SuccColor == TopoSorter::WHITE) {
 81 |         if (!recursiveDFSToposort(Succ))
 82 |           return false;
 83 |       } else if (SuccColor == TopoSorter::GREY) {
 84 |         // This detects a cycle because grey vertices are all ancestors of the
 85 |         // currently explored vertex (in other words, they're "on the stack").
 86 |         outs() << "  Detected cycle: edge from " << BB->getName() << " to "
 87 |                << Succ->getName() << "\n";
 88 |         return false;
 89 |       }
 90 |     }
 91 |     // This BB is finished (fully explored), so we can add it to the vector.
 92 |     ColorMap[BB] = TopoSorter::BLACK;
 93 |     SortedBBs.push_back(BB);
 94 |     return true;
 95 |   }
 96 | };
 97 | 
 98 | class AnalyzeBBGraph : public FunctionPass {
 99 | public:
100 |   AnalyzeBBGraph(const std::string &AnalysisKind)
101 |       : FunctionPass(ID), AnalysisKind(AnalysisKind) {}
102 | 
103 |   virtual bool runOnFunction(Function &F) {
104 |     if (AnalysisKind == "-topo") {
105 |       TopoSorter TS;
106 |       TS.runToposort(F);
107 |     } else if (AnalysisKind == "-po") {
108 |       // Use LLVM's post-order iterator to produce a reverse topological sort.
109 |       // Note that this doesn't detect cycles so if the graph is not a DAG, the
110 |       // result is not a true topological sort.
111 |       outs() << "Basic blocks of " << F.getName() << " in post-order:\n";
112 |       for (po_iterator<BasicBlock *> I = po_begin(&F.getEntryBlock()),
113 |                                      IE = po_end(&F.getEntryBlock());
114 |            I != IE; ++I) {
115 |         outs() << "  " << (*I)->getName() << "\n";
116 |       }
117 |     } else if (AnalysisKind == "-scc") {
118 |       // Use LLVM's Strongly Connected Components (SCCs) iterator to produce
119 |       // a reverse topological sort of SCCs.
120 |       outs() << "SCCs for " << F.getName() << " in post-order:\n";
121 |       for (scc_iterator<Function *> I = scc_begin(&F), IE = scc_end(&F);
122 |            I != IE; ++I) {
123 |         // Obtain the vector of BBs in this SCC and print it out.
124 |         const std::vector<BasicBlock *> &SCCBBs = *I;
125 |         outs() << "  SCC: ";
126 |         for (std::vector<BasicBlock *>::const_iterator BBI = SCCBBs.begin(),
127 |                                                        BBIE = SCCBBs.end();
128 |              BBI != BBIE; ++BBI) {
129 |           outs() << (*BBI)->getName() << "  ";
130 |         }
131 |         outs() << "\n";
132 |       }
133 |     } else {
134 |       outs() << "Unknown analysis kind: " << AnalysisKind << "\n";
135 |     }
136 |     return false;
137 |   }
138 | 
139 |   // The address of this member is used to uniquely identify the class. This is
140 |   // used by LLVM's own RTTI mechanism.
141 |   static char ID;
142 | 
143 | private:
144 |   std::string AnalysisKind;
145 | };
146 | 
147 | char AnalyzeBBGraph::ID = 0;
148 | 
149 | int main(int argc, char **argv) {
150 |   if (argc < 3) {
151 |     // Using very basic command-line argument parsing here...
152 |     errs() << "Usage: " << argv[0] << " -[topo|po|scc] <IR file>\n";
153 |     return 1;
154 |   }
155 | 
156 |   // Parse the input LLVM IR file into a module.
157 |   SMDiagnostic Err;
158 |   LLVMContext Context;
159 |   std::unique_ptr<Module> Mod(parseIRFile(argv[2], Err, Context));
160 |   if (!Mod) {
161 |     Err.print(argv[0], errs());
162 |     return 1;
163 |   }
164 | 
165 |   // Create a pass manager and fill it with the passes we want to run.
166 |   legacy::PassManager PM;
167 |   PM.add(new AnalyzeBBGraph(std::string(argv[1])));
168 |   PM.run(*Mod);
169 | 
170 |   return 0;
171 | }
172 | 


--------------------------------------------------------------------------------
/src_clang/ClangCheck.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // This is the source code of the clang-check tool, taken directly from the
  3 | // Clang repository (tools/clang-check/ClangCheck.cpp) to serve as a canary for
  4 | // linking with Clang libraries properly.
  5 | //
  6 | // See below for the (LLVM) license of this file.
  7 | // Eli Bendersky (eliben@gmail.com)
  8 | //------------------------------------------------------------------------------
  9 | 
 10 | //===--- tools/clang-check/ClangCheck.cpp - Clang check tool --------------===//
 11 | //
 12 | //                     The LLVM Compiler Infrastructure
 13 | //
 14 | // This file is distributed under the University of Illinois Open Source
 15 | // License. See LICENSE.TXT for details.
 16 | //
 17 | //===----------------------------------------------------------------------===//
 18 | //
 19 | //  This file implements a clang-check tool that runs clang based on the info
 20 | //  stored in a compilation database.
 21 | //
 22 | //  This tool uses the Clang Tooling infrastructure, see
 23 | //    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 24 | //  for details on setting it up with LLVM source tree.
 25 | //
 26 | //===----------------------------------------------------------------------===//
 27 | 
 28 | #include "clang/AST/ASTConsumer.h"
 29 | #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
 30 | #include "clang/Driver/Options.h"
 31 | #include "clang/Frontend/ASTConsumers.h"
 32 | #include "clang/Frontend/CompilerInstance.h"
 33 | #include "clang/Rewrite/Frontend/FixItRewriter.h"
 34 | #include "clang/Rewrite/Frontend/FrontendActions.h"
 35 | #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
 36 | #include "clang/Tooling/CommonOptionsParser.h"
 37 | #include "clang/Tooling/Tooling.h"
 38 | #include "llvm/ADT/STLExtras.h"
 39 | #include "llvm/Option/OptTable.h"
 40 | #include "llvm/Support/Path.h"
 41 | #include "llvm/Support/Signals.h"
 42 | #include "llvm/Support/TargetSelect.h"
 43 | 
 44 | using namespace clang::driver;
 45 | using namespace clang::tooling;
 46 | using namespace llvm;
 47 | 
 48 | static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 49 | static cl::extrahelp MoreHelp(
 50 |     "\tFor example, to run clang-check on all files in a subtree of the\n"
 51 |     "\tsource tree, use:\n"
 52 |     "\n"
 53 |     "\t  find path/in/subtree -name '*.cpp'|xargs clang-check\n"
 54 |     "\n"
 55 |     "\tor using a specific build path:\n"
 56 |     "\n"
 57 |     "\t  find path/in/subtree -name '*.cpp'|xargs clang-check -p build/path\n"
 58 |     "\n"
 59 |     "\tNote, that path/in/subtree and current directory should follow the\n"
 60 |     "\trules described above.\n"
 61 |     "\n"
 62 | );
 63 | 
 64 | static cl::OptionCategory ClangCheckCategory("clang-check options");
 65 | static std::unique_ptr<opt::OptTable> Options(createDriverOptTable());
 66 | static cl::opt<bool>
 67 | ASTDump("ast-dump", cl::desc(Options->getOptionHelpText(options::OPT_ast_dump)),
 68 |         cl::cat(ClangCheckCategory));
 69 | static cl::opt<bool>
 70 | ASTList("ast-list", cl::desc(Options->getOptionHelpText(options::OPT_ast_list)),
 71 |         cl::cat(ClangCheckCategory));
 72 | static cl::opt<bool>
 73 | ASTPrint("ast-print",
 74 |          cl::desc(Options->getOptionHelpText(options::OPT_ast_print)),
 75 |          cl::cat(ClangCheckCategory));
 76 | static cl::opt<std::string> ASTDumpFilter(
 77 |     "ast-dump-filter",
 78 |     cl::desc(Options->getOptionHelpText(options::OPT_ast_dump_filter)),
 79 |     cl::cat(ClangCheckCategory));
 80 | static cl::opt<bool>
 81 | Analyze("analyze", cl::desc(Options->getOptionHelpText(options::OPT_analyze)),
 82 |         cl::cat(ClangCheckCategory));
 83 | 
 84 | static cl::opt<bool>
 85 | Fixit("fixit", cl::desc(Options->getOptionHelpText(options::OPT_fixit)),
 86 |       cl::cat(ClangCheckCategory));
 87 | static cl::opt<bool> FixWhatYouCan(
 88 |     "fix-what-you-can",
 89 |     cl::desc(Options->getOptionHelpText(options::OPT_fix_what_you_can)),
 90 |     cl::cat(ClangCheckCategory));
 91 | 
 92 | namespace {
 93 | 
 94 | // FIXME: Move FixItRewriteInPlace from lib/Rewrite/Frontend/FrontendActions.cpp
 95 | // into a header file and reuse that.
 96 | class FixItOptions : public clang::FixItOptions {
 97 | public:
 98 |   FixItOptions() {
 99 |     FixWhatYouCan = ::FixWhatYouCan;
100 |   }
101 | 
102 |   std::string RewriteFilename(const std::string& filename, int &fd) override {
103 |     assert(llvm::sys::path::is_absolute(filename) &&
104 |            "clang-fixit expects absolute paths only.");
105 | 
106 |     // We don't need to do permission checking here since clang will diagnose
107 |     // any I/O errors itself.
108 | 
109 |     fd = -1;  // No file descriptor for file.
110 | 
111 |     return filename;
112 |   }
113 | };
114 | 
115 | /// Subclasses \c clang::FixItRewriter to not count fixed errors/warnings
116 | /// in the final error counts.
117 | ///
118 | /// This has the side-effect that clang-check -fixit exits with code 0 on
119 | /// successfully fixing all errors.
120 | class FixItRewriter : public clang::FixItRewriter {
121 | public:
122 |   FixItRewriter(clang::DiagnosticsEngine& Diags,
123 |                 clang::SourceManager& SourceMgr,
124 |                 const clang::LangOptions& LangOpts,
125 |                 clang::FixItOptions* FixItOpts)
126 |       : clang::FixItRewriter(Diags, SourceMgr, LangOpts, FixItOpts) {
127 |   }
128 | 
129 |   bool IncludeInDiagnosticCounts() const override { return false; }
130 | };
131 | 
132 | /// Subclasses \c clang::FixItAction so that we can install the custom
133 | /// \c FixItRewriter.
134 | class FixItAction : public clang::FixItAction {
135 | public:
136 |   bool BeginSourceFileAction(clang::CompilerInstance& CI) override {
137 |     FixItOpts.reset(new FixItOptions);
138 |     Rewriter.reset(new FixItRewriter(CI.getDiagnostics(), CI.getSourceManager(),
139 |                                      CI.getLangOpts(), FixItOpts.get()));
140 |     return true;
141 |   }
142 | };
143 | 
144 | class ClangCheckActionFactory {
145 | public:
146 |   std::unique_ptr<clang::ASTConsumer> newASTConsumer() {
147 |     if (ASTList)
148 |       return clang::CreateASTDeclNodeLister();
149 |     if (ASTDump)
150 |       return clang::CreateASTDumper(nullptr /*Dump to stdout.*/,
151 |                                     ASTDumpFilter,
152 |                                     /*DumpDecls=*/true,
153 |                                     /*Deserialize=*/false,
154 |                                     /*DumpLookups=*/false);
155 |     if (ASTPrint)
156 |       return clang::CreateASTPrinter(nullptr, ASTDumpFilter);
157 |     return llvm::make_unique<clang::ASTConsumer>();
158 |   }
159 | };
160 | 
161 | } // namespace
162 | 
163 | int main(int argc, const char **argv) {
164 |   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
165 | 
166 |   // Initialize targets for clang module support.
167 |   llvm::InitializeAllTargets();
168 |   llvm::InitializeAllTargetMCs();
169 |   llvm::InitializeAllAsmPrinters();
170 |   llvm::InitializeAllAsmParsers();
171 | 
172 |   CommonOptionsParser OptionsParser(argc, argv, ClangCheckCategory);
173 |   ClangTool Tool(OptionsParser.getCompilations(),
174 |                  OptionsParser.getSourcePathList());
175 | 
176 |   // Clear adjusters because -fsyntax-only is inserted by the default chain.
177 |   Tool.clearArgumentsAdjusters();
178 |   Tool.appendArgumentsAdjuster(getClangStripOutputAdjuster());
179 | 
180 |   // Running the analyzer requires --analyze. Other modes can work with the
181 |   // -fsyntax-only option.
182 |   Tool.appendArgumentsAdjuster(getInsertArgumentAdjuster(
183 |       Analyze ? "--analyze" : "-fsyntax-only", ArgumentInsertPosition::BEGIN));
184 | 
185 |   ClangCheckActionFactory CheckFactory;
186 |   std::unique_ptr<FrontendActionFactory> FrontendFactory;
187 | 
188 |   // Choose the correct factory based on the selected mode.
189 |   if (Analyze)
190 |     FrontendFactory = newFrontendActionFactory<clang::ento::AnalysisAction>();
191 |   else if (Fixit)
192 |     FrontendFactory = newFrontendActionFactory<FixItAction>();
193 |   else
194 |     FrontendFactory = newFrontendActionFactory(&CheckFactory);
195 | 
196 |   return Tool.run(FrontendFactory.get());
197 | }
198 | 


--------------------------------------------------------------------------------
/src_llvm/experimental/build_llvm_ir.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // Building LLVM IR via the C++ API and JIT-calling it.
  3 | //
  4 | // Eli Bendersky (eliben@gmail.com)
  5 | // This code is in the public domain
  6 | //------------------------------------------------------------------------------
  7 | #include "llvm/ADT/STLExtras.h"
  8 | #include "llvm/ExecutionEngine/JITSymbol.h"
  9 | #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
 10 | #include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
 11 | #include "llvm/ExecutionEngine/Orc/LambdaResolver.h"
 12 | #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
 13 | #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
 14 | #include "llvm/ExecutionEngine/RuntimeDyld.h"
 15 | #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 16 | #include "llvm/IR/DerivedTypes.h"
 17 | #include "llvm/IR/IRBuilder.h"
 18 | #include "llvm/IR/Mangler.h"
 19 | #include "llvm/IR/Module.h"
 20 | #include "llvm/IR/Verifier.h"
 21 | #include "llvm/Support/DynamicLibrary.h"
 22 | #include "llvm/Support/TargetSelect.h"
 23 | #include "llvm/Transforms/IPO/PassManagerBuilder.h"
 24 | #include <memory>
 25 | 
 26 | using namespace llvm;
 27 | 
 28 | // A type encapsulating simple Orc JIT functionality. Loosely based on the
 29 | // KaleidoscopeJIT example in the LLVM tree. Doesn't support cross-module
 30 | // symbol resolution; this JIT is best used with just a single module.
 31 | class SimpleOrcJIT {
 32 | public:
 33 |   // This sample doesn't implement on-request or lazy compilation. It therefore
 34 |   // uses Orc's eager compilation layer directly - IRCompileLayer. It also uses
 35 |   // the basis object layer - ObjectLinkingLayer - directly.
 36 |   // Orc's SimpleCompiler is used to actually compile the module; it runs LLVM's
 37 |   // codegen and MC on the module, producing an object file in memory. No
 38 |   // IR-level optimizations are run by the JIT.
 39 |   typedef orc::RTDyldObjectLinkingLayer<> ObjLayerT;
 40 |   typedef orc::IRCompileLayer<ObjLayerT> CompileLayerT;
 41 |   typedef CompileLayerT::ModuleSetHandleT ModuleHandleT;
 42 | 
 43 |   SimpleOrcJIT()
 44 |       : TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
 45 |         CompileLayer(ObjectLayer, orc::SimpleCompiler(*TM)) {
 46 |     std::string s;
 47 |     if (llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr, &s)) {
 48 |       errs() << "ERROR: LoadLibraryPermanently returned false"
 49 |              << "; error string=" << s << "\n";
 50 |     }
 51 |   }
 52 | 
 53 |   TargetMachine &getTargetMachine() { return *TM; }
 54 | 
 55 |   template <typename T> static std::vector<T> singletonSet(T t) {
 56 |     std::vector<T> Vec;
 57 |     Vec.push_back(std::move(t));
 58 |     return Vec;
 59 |   }
 60 | 
 61 |   ModuleHandleT addModule(std::unique_ptr<Module> M) {
 62 |     // We need a memory manager to allocate memory and resolve symbols for this
 63 |     // new module. Create one that resolves symbols by looking back into the
 64 |     // JIT.
 65 |     auto Resolver = orc::createLambdaResolver(
 66 |         [&](const std::string &Name) {
 67 |           if (auto Sym = findMangledSymbol(Name))
 68 |             return Sym;
 69 |           return JITSymbol(nullptr);
 70 |         },
 71 |         [](const std::string &S) { return nullptr; });
 72 |     auto H = CompileLayer.addModuleSet(singletonSet(std::move(M)),
 73 |                                        make_unique<SectionMemoryManager>(),
 74 |                                        std::move(Resolver));
 75 | 
 76 |     ModuleHandles.push_back(H);
 77 |     return H;
 78 |   }
 79 | 
 80 |   // Remove a module from the JIT.
 81 |   void removeModule(ModuleHandleT H) {
 82 |     ModuleHandles.erase(
 83 |         std::find(ModuleHandles.begin(), ModuleHandles.end(), H));
 84 |     CompileLayer.removeModuleSet(H);
 85 |   }
 86 | 
 87 |   JITSymbol findSymbol(const std::string Name) {
 88 |     return findMangledSymbol(mangle(Name));
 89 |   }
 90 | 
 91 |   std::string mangle(const std::string &Name) {
 92 |     std::string MangledName;
 93 |     {
 94 |       raw_string_ostream MangledNameStream(MangledName);
 95 |       Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
 96 |     }
 97 |     return MangledName;
 98 |   }
 99 | 
100 |   JITSymbol findMangledSymbol(const std::string &Name) {
101 |     const bool ExportedSymbolsOnly = true;
102 | 
103 |     // Search modules in reverse order: from last added to first added.
104 |     // This is the opposite of the usual search order for dlsym, but makes more
105 |     // sense in a REPL where we want to bind to the newest available definition.
106 |     for (auto H : make_range(ModuleHandles.rbegin(), ModuleHandles.rend()))
107 |       if (auto Sym = CompileLayer.findSymbolIn(H, Name, ExportedSymbolsOnly))
108 |         return Sym;
109 | 
110 |     // If we can't find the symbol in the JIT, try looking in the host process.
111 |     if (auto SymAddr = RTDyldMemoryManager::getSymbolAddressInProcess(Name))
112 |       return JITSymbol(SymAddr, JITSymbolFlags::Exported);
113 | 
114 |     return nullptr;
115 |   }
116 | 
117 | private:
118 |   std::unique_ptr<TargetMachine> TM;
119 |   const DataLayout DL;
120 |   ObjLayerT ObjectLayer;
121 |   CompileLayerT CompileLayer;
122 |   std::vector<ModuleHandleT> ModuleHandles;
123 | };
124 | 
125 | Function *MakeFunction(Module *Mod, std::string name, Function *printdfunc) {
126 |   LLVMContext &Context = Mod->getContext();
127 |   std::vector<Type *> Args(3, Type::getDoubleTy(Context));
128 |   FunctionType *FT = FunctionType::get(Type::getDoubleTy(Context), Args, false);
129 |   Function *F = Function::Create(FT, Function::ExternalLinkage, name, Mod);
130 |   Function::arg_iterator arg_iter = F->arg_begin();
131 |   Value *arg1 = &*(arg_iter++);
132 |   arg1->setName("arg1");
133 |   Value *arg2 = &*(arg_iter++);
134 |   arg2->setName("arg2");
135 |   Value *arg3 = &*(arg_iter++);
136 |   arg3->setName("arg3");
137 | 
138 |   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
139 | 
140 |   // Create an IRBuilder pointing to the beginning of the entry block, and add
141 |   // a couple of instructions.
142 |   IRBuilder<> Builder(Context);
143 |   Builder.SetInsertPoint(BB);
144 | 
145 |   Value *fa = Builder.CreateFAdd(arg1, arg2);
146 |   Value *fb = Builder.CreateFAdd(fa, arg3);
147 |   Value *fc = Builder.CreateFAdd(arg1, arg2);
148 | 
149 |   Builder.CreateCall(printdfunc, {fc});
150 | 
151 |   Value *fd = Builder.CreateFAdd(fb, fc);
152 | 
153 |   Builder.CreateRet(fd);
154 | 
155 |   return F;
156 | }
157 | 
158 | /// printd - printf that takes a double prints it as "%f\n", returning 0.
159 | extern "C" double printd(double X) {
160 |   fprintf(stderr, "%f\n", X);
161 |   return 0;
162 | }
163 | 
164 | // Signature of the function we expect.
165 | typedef double (*FooTy)(double, double, double);
166 | 
167 | int main(int argc, char **argv) {
168 |   LLVMContext Context;
169 |   std::unique_ptr<Module> Mod = make_unique<Module>("my module", Context);
170 | 
171 |   std::string funcname = "foo";
172 | 
173 |   FunctionType *FT =
174 |       FunctionType::get(Type::getVoidTy(Mod->getContext()),
175 |                         {Type::getDoubleTy(Mod->getContext())}, false);
176 |   Function *printdfunc =
177 |       Function::Create(FT, Function::ExternalLinkage, "printd", Mod.get());
178 | 
179 |   Function *Func = MakeFunction(Mod.get(), funcname, printdfunc);
180 | 
181 |   // This is required to initialize the MC layer for our (native) target.
182 |   InitializeNativeTarget();
183 |   InitializeNativeTargetAsmPrinter();
184 | 
185 |   SimpleOrcJIT JIT;
186 |   Mod->setDataLayout(JIT.getTargetMachine().createDataLayout());
187 | 
188 |   PassManagerBuilder Builder;
189 |   Builder.OptLevel = 3;
190 |   Builder.SizeLevel = 0;
191 |   Builder.LoopVectorize = true;
192 |   Builder.SLPVectorize = true;
193 |   JIT.getTargetMachine().adjustPassManager(Builder);
194 |   auto FPM = llvm::make_unique<legacy::FunctionPassManager>(Mod.get());
195 |   Builder.populateFunctionPassManager(*FPM);
196 |   FPM->doInitialization();
197 | 
198 |   if (verifyFunction(*Func, &errs())) {
199 |     errs() << "Error verifying function... exiting\n";
200 |     return 1;
201 |   }
202 |   FPM->run(*Func);
203 |   Mod->dump();
204 | 
205 |   JIT.addModule(std::move(Mod));
206 | 
207 |   JITSymbol FooSym = JIT.findSymbol(funcname);
208 |   if (!FooSym) {
209 |     errs() << "Unable to find symbol " << funcname << " in module\n";
210 |     return 1;
211 |   }
212 | 
213 |   FooTy FooPtr = reinterpret_cast<FooTy>(FooSym.getAddress());
214 |   outs() << FooPtr(2.0, 3.0, 7.7) << "\n";
215 | 
216 |   return 0;
217 | }
218 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
  1 | #-------------------------------------------------------------------------------
  2 | # Sample makefile for building the code samples. Read inline comments for
  3 | # documentation.
  4 | #
  5 | # Eli Bendersky (eliben@gmail.com)
  6 | # This code is in the public domain
  7 | #-------------------------------------------------------------------------------
  8 | 
  9 | # The following variables will likely need to be customized, depending on where
 10 | # and how you built LLVM & Clang. They can be overridden by setting them on the
 11 | # make command line: "make VARNAME=VALUE", etc.
 12 | 
 13 | # LLVM_SRC_PATH is the path to the root of the checked out source code. This
 14 | # directory should contain the configure script, the include/ and lib/
 15 | # directories of LLVM, Clang in tools/clang/, etc.
 16 | #
 17 | # The most recent build from source of LLVM I did used the following cmake
 18 | # invocation:
 19 | #
 20 | # $ cmake -DCMAKE_BUILD_TYPE=Release \
 21 | #         -DLLVM_ENABLE_ASSERTIONS=ON \
 22 | #         -DCMAKE_C_FLAGS=-DLLVM_ENABLE_DUMP \
 23 | #         -DCMAKE_CXX_FLAGS=-DLLVM_ENABLE_DUMP \
 24 | #         -DLLVM_TARGETS_TO_BUILD="X86" \
 25 | #         -G Ninja
 26 | #
 27 | # Note that this is a release build with assertions enabled, and with
 28 | # LLVM_ENABLE_DUMP explicitly passed. This is required to get the LLVM IR-level
 29 | # 'dump' methods to work. With debug builds, assertions should be enabled by
 30 | # default. Also note that a fairly recent version of cmake is required; the
 31 | # latest I've been using is 3.5.2
 32 | #
 33 | # It is recommended to use a recent Clang to build LLVM itself. For example if
 34 | # you have a Clang binary release in $CLANGDIR, cmake should be run with:
 35 | #
 36 | # $ CC=$CLANGDIR/bin/clang CXX=$CLANGDIR/bin/clang++ cmake ....
 37 | #
 38 | # Alternatively, if you're building vs. a binary distribution of LLVM
 39 | # (downloaded from llvm.org), then LLVM_SRC_PATH can point to the main untarred
 40 | # directory of the binary download (the directory that has bin/, lib/, include/
 41 | # and other directories inside).
 42 | # See the build_vs_released_binary.sh script for an example.
 43 | #
 44 | #  Changes for building against the Homebrew install of llvm on OSX platforms
 45 | #  (provided by b.van straalen  Lawrence Berkeley National Lab)
 46 | #  1. >brew install llvm --with-toolchain
 47 | #  2. LLVM_SRC_PATH := /usr/local/opt/llvm
 48 | #  3. LLVM_BUILD_PATH := $(LLVM_SRC_PATH)
 49 | #  4. CXX:=$(LLVM_BUILD_PATH)/bin/clang++
 50 | #  5. PLUGIN_LDFLAGS := -shared -undefined dynamic_lookup
 51 | #  6. -Wl,--start-group \   changed to  -Wl, \
 52 | #  7  -Wl,--end-group    changed to  -Wl,
 53 | 
 54 | LLVM_SRC_PATH := $$HOME/llvm/llvm_svn_rw
 55 | 
 56 | # LLVM_BUILD_PATH is the directory in which you built LLVM - where you ran
 57 | # configure or cmake.
 58 | # For linking vs. a binary build of LLVM, point to the main untarred directory.
 59 | # LLVM_BIN_PATH is the directory where binaries are placed by the LLVM build
 60 | # process. It should contain the tools like opt, llc and clang. The default
 61 | # reflects a release build with CMake and Ninja. binary build of LLVM, point it
 62 | # to the bin/ directory.
 63 | LLVM_BUILD_PATH := $$HOME/llvm/build/svn-ninja-release
 64 | LLVM_BIN_PATH 	:= $(LLVM_BUILD_PATH)/bin
 65 | 
 66 | $(info -----------------------------------------------)
 67 | $(info Using LLVM_SRC_PATH = $(LLVM_SRC_PATH))
 68 | $(info Using LLVM_BUILD_PATH = $(LLVM_BUILD_PATH))
 69 | $(info Using LLVM_BIN_PATH = $(LLVM_BIN_PATH))
 70 | $(info -----------------------------------------------)
 71 | 
 72 | CXX := g++
 73 | CXXFLAGS := -fno-rtti -O0 -g
 74 | PLUGIN_CXXFLAGS := -fpic
 75 | 
 76 | LLVM_CXXFLAGS := `$(LLVM_BIN_PATH)/llvm-config --cxxflags`
 77 | LLVM_LDFLAGS := `$(LLVM_BIN_PATH)/llvm-config --ldflags --libs --system-libs`
 78 | 
 79 | # Plugins shouldn't link LLVM and Clang libs statically, because they are
 80 | # already linked into the main executable (opt or clang). LLVM doesn't like its
 81 | # libs to be linked more than once because it uses globals for configuration
 82 | # and plugin registration, and these trample over each other.
 83 | LLVM_LDFLAGS_NOLIBS := `$(LLVM_BIN_PATH)/llvm-config --ldflags`
 84 | PLUGIN_LDFLAGS := -shared
 85 | 
 86 | # These are required when compiling vs. a source distribution of Clang. For
 87 | # binary distributions llvm-config --cxxflags gives the right path.
 88 | CLANG_INCLUDES := \
 89 | 	-I$(LLVM_SRC_PATH)/tools/clang/include \
 90 | 	-I$(LLVM_BUILD_PATH)/tools/clang/include
 91 | 
 92 | # List of Clang libraries to link. The proper -L will be provided by the
 93 | # call to llvm-config
 94 | # Note that I'm using -Wl,--{start|end}-group around the Clang libs; this is
 95 | # because there are circular dependencies that make the correct order difficult
 96 | # to specify and maintain. The linker group options make the linking somewhat
 97 | # slower, but IMHO they're still perfectly fine for tools that link with Clang.
 98 | CLANG_LIBS := \
 99 | 	-Wl,--start-group \
100 | 	-lclangAST \
101 | 	-lclangASTMatchers \
102 | 	-lclangAnalysis \
103 | 	-lclangBasic \
104 | 	-lclangDriver \
105 | 	-lclangEdit \
106 | 	-lclangFrontend \
107 | 	-lclangFrontendTool \
108 | 	-lclangLex \
109 | 	-lclangParse \
110 | 	-lclangSema \
111 | 	-lclangEdit \
112 | 	-lclangRewrite \
113 | 	-lclangRewriteFrontend \
114 | 	-lclangStaticAnalyzerFrontend \
115 | 	-lclangStaticAnalyzerCheckers \
116 | 	-lclangStaticAnalyzerCore \
117 | 	-lclangCrossTU \
118 | 	-lclangIndex \
119 | 	-lclangSerialization \
120 | 	-lclangToolingCore \
121 | 	-lclangTooling \
122 | 	-lclangFormat \
123 | 	-Wl,--end-group
124 | 
125 | # Internal paths in this project: where to find sources, and where to put
126 | # build artifacts.
127 | SRC_LLVM_DIR := src_llvm
128 | SRC_CLANG_DIR := src_clang
129 | BUILDDIR := build
130 | 
131 | .PHONY: all
132 | all: make_builddir \
133 | 	emit_build_config \
134 | 	$(BUILDDIR)/bb_toposort_sccs \
135 | 	$(BUILDDIR)/simple_module_pass \
136 | 	$(BUILDDIR)/simple_bb_pass \
137 | 	$(BUILDDIR)/analyze_geps \
138 | 	$(BUILDDIR)/hello_pass.so \
139 | 	$(BUILDDIR)/replace_threadidx_with_call \
140 | 	$(BUILDDIR)/access_debug_metadata \
141 | 	$(BUILDDIR)/clang-check \
142 | 	$(BUILDDIR)/rewritersample \
143 | 	$(BUILDDIR)/matchers_rewriter \
144 | 	$(BUILDDIR)/tooling_sample \
145 | 	$(BUILDDIR)/plugin_print_funcnames.so
146 | 
147 | .PHONY: test
148 | test: emit_build_config
149 | 	python3 test/all_tests.py
150 | 
151 | .PHONY: emit_build_config
152 | emit_build_config: make_builddir
153 | 	@echo $(LLVM_BIN_PATH) > $(BUILDDIR)/_build_config
154 | 
155 | .PHONY: make_builddir
156 | make_builddir:
157 | 	@test -d $(BUILDDIR) || mkdir $(BUILDDIR)
158 | 
159 | $(BUILDDIR)/simple_bb_pass: $(SRC_LLVM_DIR)/simple_bb_pass.cpp
160 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
161 | 
162 | $(BUILDDIR)/analyze_geps: $(SRC_LLVM_DIR)/analyze_geps.cpp
163 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
164 | 
165 | $(BUILDDIR)/replace_threadidx_with_call: $(SRC_LLVM_DIR)/replace_threadidx_with_call.cpp
166 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
167 | 
168 | $(BUILDDIR)/simple_module_pass: $(SRC_LLVM_DIR)/simple_module_pass.cpp
169 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
170 | 
171 | $(BUILDDIR)/access_debug_metadata: $(SRC_LLVM_DIR)/access_debug_metadata.cpp
172 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
173 | 
174 | $(BUILDDIR)/bb_toposort_sccs: $(SRC_LLVM_DIR)/bb_toposort_sccs.cpp
175 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
176 | 
177 | $(BUILDDIR)/hello_pass.so: $(SRC_LLVM_DIR)/hello_pass.cpp
178 | 	$(CXX) $(PLUGIN_CXXFLAGS) $(CXXFLAGS) $(LLVM_CXXFLAGS) \
179 | 		$^ $(PLUGIN_LDFLAGS) $(LLVM_LDFLAGS_NOLIBS) -o $@
180 | 
181 | $(BUILDDIR)/clang-check: $(SRC_CLANG_DIR)/ClangCheck.cpp
182 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
183 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
184 | 
185 | $(BUILDDIR)/rewritersample: $(SRC_CLANG_DIR)/rewritersample.cpp
186 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
187 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
188 | 
189 | $(BUILDDIR)/tooling_sample: $(SRC_CLANG_DIR)/tooling_sample.cpp
190 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
191 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
192 | 
193 | $(BUILDDIR)/matchers_rewriter: $(SRC_CLANG_DIR)/matchers_rewriter.cpp
194 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
195 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
196 | 
197 | $(BUILDDIR)/plugin_print_funcnames.so: $(SRC_CLANG_DIR)/plugin_print_funcnames.cpp
198 | 	$(CXX) $(PLUGIN_CXXFLAGS) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
199 | 		$(PLUGIN_LDFLAGS) $(LLVM_LDFLAGS_NOLIBS) -o $@
200 | 
201 | # Experimental tools - use at your own peril.
202 | #
203 | .PHONY: experimental_tools
204 | experimental_tools: make_builddir \
205 | 	emit_build_config \
206 | 	$(BUILDDIR)/loop_info \
207 | 	$(BUILDDIR)/build_llvm_ir \
208 | 	$(BUILDDIR)/remove-cstr-calls \
209 | 	$(BUILDDIR)/toplevel_decls \
210 | 	$(BUILDDIR)/try_matcher
211 | 
212 | $(BUILDDIR)/loop_info: $(SRC_LLVM_DIR)/experimental/loop_info.cpp
213 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ $(LLVM_LDFLAGS) -o $@
214 | 
215 | # build_llvm_ir needs -rdynamic so that it can dlsym symbols from its own
216 | # binary in the JIT.
217 | $(BUILDDIR)/build_llvm_ir: $(SRC_LLVM_DIR)/experimental/build_llvm_ir.cpp
218 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $^ -rdynamic $(LLVM_LDFLAGS) -o $@
219 | 
220 | $(BUILDDIR)/remove-cstr-calls: $(SRC_CLANG_DIR)/experimental/RemoveCStrCalls.cpp
221 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
222 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
223 | 
224 | $(BUILDDIR)/toplevel_decls: $(SRC_CLANG_DIR)/experimental/toplevel_decls.cpp
225 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
226 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
227 | 
228 | $(BUILDDIR)/try_matcher: $(SRC_CLANG_DIR)/experimental/try_matcher.cpp
229 | 	$(CXX) $(CXXFLAGS) $(LLVM_CXXFLAGS) $(CLANG_INCLUDES) $^ \
230 | 		$(CLANG_LIBS) $(LLVM_LDFLAGS) -o $@
231 | 
232 | .PHONY: clean format
233 | 
234 | clean:
235 | 	rm -rf $(BUILDDIR)/* *.dot test/*.pyc test/__pycache__
236 | 
237 | format:
238 | 	find . -name "*.cpp" | xargs clang-format -style=file -i
239 | 


--------------------------------------------------------------------------------
/inputs/types.ll:
--------------------------------------------------------------------------------
  1 | ; ModuleID = '<stdin>'
  2 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
  3 | target triple = "x86_64-unknown-linux-gnu"
  4 | 
  5 | %struct.mystruct = type { double, i8, i32, [10 x i8] }
  6 | 
  7 | ; Function Attrs: nounwind uwtable
  8 | define void @structadder(%struct.mystruct* byval nocapture readonly align 8 %a, %struct.mystruct* byval nocapture readonly align 8 %b, %struct.mystruct* %out) #0 {
  9 | entry:
 10 |   %ss = alloca %struct.mystruct, align 8
 11 |   %d = getelementptr inbounds %struct.mystruct, %struct.mystruct* %a, i64 0, i32 0
 12 |   %0 = load double, double* %d, align 8, !tbaa !1
 13 |   %d1 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %b, i64 0, i32 0
 14 |   %1 = load double, double* %d1, align 8, !tbaa !1
 15 |   %add = fadd double %0, %1
 16 |   %d2 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 0
 17 |   store double %add, double* %d2, align 8, !tbaa !1
 18 |   %c = getelementptr inbounds %struct.mystruct, %struct.mystruct* %a, i64 0, i32 1
 19 |   %2 = bitcast i8* %c to i64*
 20 |   %3 = load i64, i64* %2, align 8
 21 |   %4 = trunc i64 %3 to i8
 22 |   %c3 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %b, i64 0, i32 1
 23 |   %5 = bitcast i8* %c3 to i64*
 24 |   %6 = load i64, i64* %5, align 8
 25 |   %7 = trunc i64 %6 to i8
 26 |   %add5 = add i8 %7, %4
 27 |   %c7 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 1
 28 |   store i8 %add5, i8* %c7, align 8, !tbaa !7
 29 |   %8 = lshr i64 %3, 32
 30 |   %9 = trunc i64 %8 to i32
 31 |   %10 = lshr i64 %6, 32
 32 |   %11 = trunc i64 %10 to i32
 33 |   %add9 = add i32 %11, %9
 34 |   %i10 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 2
 35 |   store i32 %add9, i32* %i10, align 4, !tbaa !8
 36 |   %cmp40 = icmp eq i32 %11, 0
 37 |   br i1 %cmp40, label %for.end, label %overflow.checked
 38 | 
 39 | overflow.checked:                                 ; preds = %entry
 40 |   %12 = lshr i64 %6, 32
 41 |   %13 = add nuw nsw i64 %12, 4294967295
 42 |   %14 = and i64 %13, 4294967295
 43 |   %15 = add nuw nsw i64 %14, 1
 44 |   %end.idx = add nuw nsw i64 %14, 1
 45 |   %n.mod.vf = and i64 %12, 31
 46 |   %n.vec = sub nsw i64 %15, %n.mod.vf
 47 |   %cmp.zero = icmp eq i64 %15, %n.mod.vf
 48 |   br i1 %cmp.zero, label %middle.block, label %vector.body.preheader
 49 | 
 50 | vector.body.preheader:                            ; preds = %overflow.checked
 51 |   br label %vector.body
 52 | 
 53 | vector.body:                                      ; preds = %vector.body, %vector.body.preheader
 54 |   %index = phi i64 [ %index.next, %vector.body ], [ 0, %vector.body.preheader ]
 55 |   %16 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %a, i64 0, i32 3, i64 %index
 56 |   %17 = bitcast i8* %16 to <16 x i8>*
 57 |   %wide.load = load <16 x i8>, <16 x i8>* %17, align 8, !tbaa !9
 58 |   %.sum49 = or i64 %index, 16
 59 |   %18 = getelementptr %struct.mystruct, %struct.mystruct* %a, i64 0, i32 3, i64 %.sum49
 60 |   %19 = bitcast i8* %18 to <16 x i8>*
 61 |   %wide.load43 = load <16 x i8>, <16 x i8>* %19, align 8, !tbaa !9
 62 |   %20 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %b, i64 0, i32 3, i64 %index
 63 |   %21 = bitcast i8* %20 to <16 x i8>*
 64 |   %wide.load44 = load <16 x i8>, <16 x i8>* %21, align 8, !tbaa !9
 65 |   %.sum50 = or i64 %index, 16
 66 |   %22 = getelementptr %struct.mystruct, %struct.mystruct* %b, i64 0, i32 3, i64 %.sum50
 67 |   %23 = bitcast i8* %22 to <16 x i8>*
 68 |   %wide.load45 = load <16 x i8>, <16 x i8>* %23, align 8, !tbaa !9
 69 |   %24 = add <16 x i8> %wide.load44, %wide.load
 70 |   %25 = add <16 x i8> %wide.load45, %wide.load43
 71 |   %26 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 3, i64 %index
 72 |   %27 = bitcast i8* %26 to <16 x i8>*
 73 |   store <16 x i8> %24, <16 x i8>* %27, align 8, !tbaa !9
 74 |   %.sum51 = or i64 %index, 16
 75 |   %28 = getelementptr %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 3, i64 %.sum51
 76 |   %29 = bitcast i8* %28 to <16 x i8>*
 77 |   store <16 x i8> %25, <16 x i8>* %29, align 8, !tbaa !9
 78 |   %index.next = add i64 %index, 32
 79 |   %30 = icmp eq i64 %index.next, %n.vec
 80 |   br i1 %30, label %middle.block.loopexit, label %vector.body, !llvm.loop !10
 81 | 
 82 | middle.block.loopexit:                            ; preds = %vector.body
 83 |   br label %middle.block
 84 | 
 85 | middle.block:                                     ; preds = %middle.block.loopexit, %overflow.checked
 86 |   %resume.val = phi i64 [ 0, %overflow.checked ], [ %n.vec, %middle.block.loopexit ]
 87 |   %cmp.n = icmp eq i64 %end.idx, %resume.val
 88 |   br i1 %cmp.n, label %for.end, label %for.body.preheader
 89 | 
 90 | for.body.preheader:                               ; preds = %middle.block
 91 |   %31 = lshr i64 %6, 32
 92 |   %32 = trunc i64 %31 to i32
 93 |   %33 = add i64 %resume.val, 1
 94 |   %34 = trunc i64 %33 to i32
 95 |   %35 = icmp ugt i32 %32, %34
 96 |   %umax = select i1 %35, i32 %32, i32 %34
 97 |   %36 = add i32 %umax, 1
 98 |   %37 = sub i32 %36, %34
 99 |   %38 = sub i32 %umax, %34
100 |   %xtraiter = and i32 %37, 1
101 |   %lcmp.mod = icmp ne i32 %xtraiter, 0
102 |   br i1 %lcmp.mod, label %for.body.prol, label %for.body.preheader.split
103 | 
104 | for.body.prol:                                    ; preds = %for.body.preheader
105 |   %arrayidx.prol = getelementptr inbounds %struct.mystruct, %struct.mystruct* %a, i64 0, i32 3, i64 %resume.val
106 |   %39 = load i8, i8* %arrayidx.prol, align 1, !tbaa !9
107 |   %arrayidx17.prol = getelementptr inbounds %struct.mystruct, %struct.mystruct* %b, i64 0, i32 3, i64 %resume.val
108 |   %40 = load i8, i8* %arrayidx17.prol, align 1, !tbaa !9
109 |   %add19.prol = add i8 %40, %39
110 |   %arrayidx23.prol = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 3, i64 %resume.val
111 |   store i8 %add19.prol, i8* %arrayidx23.prol, align 1, !tbaa !9
112 |   %indvars.iv.next.prol = add nuw nsw i64 %resume.val, 1
113 |   %41 = trunc i64 %indvars.iv.next.prol to i32
114 |   %cmp.prol = icmp ult i32 %41, %11
115 |   br label %for.body.preheader.split
116 | 
117 | for.body.preheader.split:                         ; preds = %for.body.prol, %for.body.preheader
118 |   %indvars.iv.unr = phi i64 [ %resume.val, %for.body.preheader ], [ %indvars.iv.next.prol, %for.body.prol ]
119 |   %42 = icmp ult i32 %38, 1
120 |   br i1 %42, label %for.end.loopexit, label %for.body.preheader.split.split
121 | 
122 | for.body.preheader.split.split:                   ; preds = %for.body.preheader.split
123 |   br label %for.body
124 | 
125 | for.body:                                         ; preds = %for.body, %for.body.preheader.split.split
126 |   %indvars.iv = phi i64 [ %indvars.iv.unr, %for.body.preheader.split.split ], [ %indvars.iv.next.1, %for.body ]
127 |   %arrayidx = getelementptr inbounds %struct.mystruct, %struct.mystruct* %a, i64 0, i32 3, i64 %indvars.iv
128 |   %43 = load i8, i8* %arrayidx, align 1, !tbaa !9
129 |   %arrayidx17 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %b, i64 0, i32 3, i64 %indvars.iv
130 |   %44 = load i8, i8* %arrayidx17, align 1, !tbaa !9
131 |   %add19 = add i8 %44, %43
132 |   %arrayidx23 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 3, i64 %indvars.iv
133 |   store i8 %add19, i8* %arrayidx23, align 1, !tbaa !9
134 |   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
135 |   %45 = trunc i64 %indvars.iv.next to i32
136 |   %arrayidx.1 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %a, i64 0, i32 3, i64 %indvars.iv.next
137 |   %46 = load i8, i8* %arrayidx.1, align 1, !tbaa !9
138 |   %arrayidx17.1 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %b, i64 0, i32 3, i64 %indvars.iv.next
139 |   %47 = load i8, i8* %arrayidx17.1, align 1, !tbaa !9
140 |   %add19.1 = add i8 %47, %46
141 |   %arrayidx23.1 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %ss, i64 0, i32 3, i64 %indvars.iv.next
142 |   store i8 %add19.1, i8* %arrayidx23.1, align 1, !tbaa !9
143 |   %indvars.iv.next.1 = add nuw nsw i64 %indvars.iv.next, 1
144 |   %48 = trunc i64 %indvars.iv.next.1 to i32
145 |   %cmp.1 = icmp ult i32 %48, %11
146 |   br i1 %cmp.1, label %for.body, label %for.end.loopexit.unr-lcssa, !llvm.loop !13
147 | 
148 | for.end.loopexit.unr-lcssa:                       ; preds = %for.body
149 |   br label %for.end.loopexit
150 | 
151 | for.end.loopexit:                                 ; preds = %for.end.loopexit.unr-lcssa, %for.body.preheader.split
152 |   br label %for.end
153 | 
154 | for.end:                                          ; preds = %for.end.loopexit, %middle.block, %entry
155 |   %arrayidx26 = getelementptr inbounds %struct.mystruct, %struct.mystruct* %out, i64 13, i32 3, i64 2
156 |   %49 = load i8, i8* %arrayidx26, align 1, !tbaa !9
157 |   %add28 = add i8 %49, 1
158 |   store i8 %add28, i8* %arrayidx26, align 1, !tbaa !9
159 |   %50 = bitcast %struct.mystruct* %out to i8*
160 |   %51 = bitcast %struct.mystruct* %ss to i8*
161 |   %call = call i8* @cpy(i8* %50, i8* %51, i32 32) #2
162 |   ret void
163 | }
164 | 
165 | declare i8* @cpy(i8*, i8*, i32) #1
166 | 
167 | attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
168 | attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
169 | attributes #2 = { nounwind }
170 | 
171 | !llvm.ident = !{!0}
172 | 
173 | !0 = !{!"clang version 3.7.0 (http://llvm.org/git/clang 805ac0a233be64ffeeff2334db1873760c1588e9) (http://llvm.org/git/llvm.git 5109ec06a641f039775e1a6bcd7d50bb04dbb8f6)"}
174 | !1 = !{!2, !3, i64 0}
175 | !2 = !{!"", !3, i64 0, !4, i64 8, !6, i64 12, !4, i64 16}
176 | !3 = !{!"double", !4, i64 0}
177 | !4 = !{!"omnipotent char", !5, i64 0}
178 | !5 = !{!"Simple C/C++ TBAA"}
179 | !6 = !{!"int", !4, i64 0}
180 | !7 = !{!2, !4, i64 8}
181 | !8 = !{!2, !6, i64 12}
182 | !9 = !{!4, !4, i64 0}
183 | !10 = distinct !{!10, !11, !12}
184 | !11 = !{!"llvm.loop.vectorize.width", i32 1}
185 | !12 = !{!"llvm.loop.interleave.count", i32 1}
186 | !13 = distinct !{!13, !11, !12}
187 | 


--------------------------------------------------------------------------------
/src_clang/experimental/RemoveCStrCalls.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // This is the source code of the remove-cstr-calls tool, taken directly from
  3 | // the Clang repository (tools/extra/remove-cstr-calls). This is for
  4 | // experimentation purpose with refactoring/replacement-based tools.
  5 | //
  6 | // What's different? Well, keeping track of changes is no fun - there's git and
  7 | // diff for that ;-)
  8 | //
  9 | // See below for the (LLVM) license of this file.
 10 | // Eli Bendersky (eliben@gmail.com)
 11 | //------------------------------------------------------------------------------
 12 | 
 13 | //===- examples/Tooling/RemoveCStrCalls.cpp - Redundant c_str call removal ===//
 14 | //
 15 | //                     The LLVM Compiler Infrastructure
 16 | //
 17 | // This file is distributed under the University of Illinois Open Source
 18 | // License. See LICENSE.TXT for details.
 19 | //
 20 | //===----------------------------------------------------------------------===//
 21 | //
 22 | //  This file implements a tool that prints replacements that remove redundant
 23 | //  calls of c_str() on strings.
 24 | //
 25 | //  Usage:
 26 | //  remove-cstr-calls <cmake-output-dir> <file1> <file2> ...
 27 | //
 28 | //  Where <cmake-output-dir> is a CMake build directory in which a file named
 29 | //  compile_commands.json exists (enable -DCMAKE_EXPORT_COMPILE_COMMANDS in
 30 | //  CMake to get this output).
 31 | //
 32 | //  <file1> ... specify the paths of files in the CMake source tree. This path
 33 | //  is looked up in the compile command database. If the path of a file is
 34 | //  absolute, it needs to point into CMake's source tree. If the path is
 35 | //  relative, the current working directory needs to be in the CMake source
 36 | //  tree and the file must be in a subdirectory of the current working
 37 | //  directory. "./" prefixes in the relative files will be automatically
 38 | //  removed, but the rest of a relative path must be a suffix of a path in
 39 | //  the compile command line database.
 40 | //
 41 | //  For example, to use remove-cstr-calls on all files in a subtree of the
 42 | //  source tree, use:
 43 | //
 44 | //    /path/in/subtree $ find . -name '*.cpp'|
 45 | //        xargs remove-cstr-calls /path/to/build
 46 | //
 47 | //===----------------------------------------------------------------------===//
 48 | 
 49 | #include "clang/ASTMatchers/ASTMatchFinder.h"
 50 | #include "clang/ASTMatchers/ASTMatchers.h"
 51 | #include "clang/Basic/SourceManager.h"
 52 | #include "clang/Frontend/FrontendActions.h"
 53 | #include "clang/Lex/Lexer.h"
 54 | #include "clang/Tooling/CompilationDatabase.h"
 55 | #include "clang/Tooling/Refactoring.h"
 56 | #include "clang/Tooling/Tooling.h"
 57 | #include "llvm/ADT/Twine.h"
 58 | #include "llvm/Support/CommandLine.h"
 59 | #include "llvm/Support/MemoryBuffer.h"
 60 | #include "llvm/Support/Path.h"
 61 | #include "llvm/Support/Signals.h"
 62 | #include "llvm/Support/raw_ostream.h"
 63 | #include <system_error>
 64 | 
 65 | using namespace clang;
 66 | using namespace clang::ast_matchers;
 67 | using namespace llvm;
 68 | using clang::tooling::newFrontendActionFactory;
 69 | using clang::tooling::Replacement;
 70 | using clang::tooling::CompilationDatabase;
 71 | 
 72 | // FIXME: Pull out helper methods in here into more fitting places.
 73 | 
 74 | // Returns the text that makes up 'node' in the source.
 75 | // Returns an empty string if the text cannot be found.
 76 | template <typename T>
 77 | static std::string getText(const SourceManager &SourceManager, const T &Node) {
 78 |   SourceLocation StartSpellingLocation =
 79 |       SourceManager.getSpellingLoc(Node.getLocStart());
 80 |   SourceLocation EndSpellingLocation =
 81 |       SourceManager.getSpellingLoc(Node.getLocEnd());
 82 |   if (!StartSpellingLocation.isValid() || !EndSpellingLocation.isValid()) {
 83 |     return std::string();
 84 |   }
 85 |   bool Invalid = true;
 86 |   const char *Text =
 87 |       SourceManager.getCharacterData(StartSpellingLocation, &Invalid);
 88 |   if (Invalid) {
 89 |     return std::string();
 90 |   }
 91 |   std::pair<FileID, unsigned> Start =
 92 |       SourceManager.getDecomposedLoc(StartSpellingLocation);
 93 |   std::pair<FileID, unsigned> End =
 94 |       SourceManager.getDecomposedLoc(Lexer::getLocForEndOfToken(
 95 |           EndSpellingLocation, 0, SourceManager, LangOptions()));
 96 |   if (Start.first != End.first) {
 97 |     // Start and end are in different files.
 98 |     return std::string();
 99 |   }
100 |   if (End.second < Start.second) {
101 |     // Shuffling text with macros may cause this.
102 |     return std::string();
103 |   }
104 |   return std::string(Text, End.second - Start.second);
105 | }
106 | 
107 | // Return true if expr needs to be put in parens when it is an argument of a
108 | // prefix unary operator, e.g. when it is a binary or ternary operator
109 | // syntactically.
110 | static bool needParensAfterUnaryOperator(const Expr &ExprNode) {
111 |   if (dyn_cast<clang::BinaryOperator>(&ExprNode) ||
112 |       dyn_cast<clang::ConditionalOperator>(&ExprNode)) {
113 |     return true;
114 |   }
115 |   if (const CXXOperatorCallExpr *op =
116 |           dyn_cast<CXXOperatorCallExpr>(&ExprNode)) {
117 |     return op->getNumArgs() == 2 && op->getOperator() != OO_PlusPlus &&
118 |            op->getOperator() != OO_MinusMinus && op->getOperator() != OO_Call &&
119 |            op->getOperator() != OO_Subscript;
120 |   }
121 |   return false;
122 | }
123 | 
124 | // Format a pointer to an expression: prefix with '*' but simplify
125 | // when it already begins with '&'.  Return empty string on failure.
126 | static std::string formatDereference(const SourceManager &SourceManager,
127 |                                      const Expr &ExprNode) {
128 |   if (const clang::UnaryOperator *Op =
129 |           dyn_cast<clang::UnaryOperator>(&ExprNode)) {
130 |     if (Op->getOpcode() == UO_AddrOf) {
131 |       // Strip leading '&'.
132 |       return getText(SourceManager, *Op->getSubExpr()->IgnoreParens());
133 |     }
134 |   }
135 |   const std::string Text = getText(SourceManager, ExprNode);
136 |   if (Text.empty())
137 |     return std::string();
138 |   // Add leading '*'.
139 |   if (needParensAfterUnaryOperator(ExprNode)) {
140 |     return std::string("*(") + Text + ")";
141 |   }
142 |   return std::string("*") + Text;
143 | }
144 | 
145 | namespace {
146 | class FixCStrCall : public ast_matchers::MatchFinder::MatchCallback {
147 | public:
148 |   FixCStrCall(tooling::Replacements *Replace) : Replace(Replace) {}
149 | 
150 |   virtual void run(const ast_matchers::MatchFinder::MatchResult &Result) {
151 |     const CallExpr *Call = Result.Nodes.getStmtAs<CallExpr>("call");
152 |     const Expr *Arg = Result.Nodes.getStmtAs<Expr>("arg");
153 |     const bool Arrow = Result.Nodes.getStmtAs<MemberExpr>("member")->isArrow();
154 |     // Replace the "call" node with the "arg" node, prefixed with '*'
155 |     // if the call was using '->' rather than '.'.
156 |     const std::string ArgText =
157 |         Arrow ? formatDereference(*Result.SourceManager, *Arg)
158 |               : getText(*Result.SourceManager, *Arg);
159 |     if (ArgText.empty())
160 |       return;
161 | 
162 |     Replacement Rep(*Result.SourceManager, Call, ArgText);
163 |     llvm::errs() << "-- Replacement:\n";
164 |     llvm::errs() << Rep.toString() << "\n";
165 |     // Replace->insert(Replacement(*Result.SourceManager, Call, ArgText));
166 |   }
167 | 
168 | private:
169 |   tooling::Replacements *Replace;
170 | };
171 | } // end namespace
172 | 
173 | const char *StringConstructor =
174 |     "::std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
175 |     "::basic_string";
176 | 
177 | const char *StringCStrMethod =
178 |     "::std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
179 |     "::c_str";
180 | 
181 | cl::opt<std::string> BuildPath(cl::Positional, cl::desc("<build-path>"));
182 | 
183 | cl::list<std::string> SourcePaths(cl::Positional,
184 |                                   cl::desc("<source0> [... <sourceN>]"),
185 |                                   cl::OneOrMore);
186 | 
187 | int main(int argc, const char **argv) {
188 |   llvm::sys::PrintStackTraceOnErrorSignal();
189 |   std::unique_ptr<CompilationDatabase> Compilations(
190 |       tooling::FixedCompilationDatabase::loadFromCommandLine(argc, argv));
191 |   cl::ParseCommandLineOptions(argc, argv);
192 |   if (!Compilations) {
193 |     std::string ErrorMessage;
194 |     Compilations =
195 |         CompilationDatabase::loadFromDirectory(BuildPath, ErrorMessage);
196 |     if (!Compilations)
197 |       llvm::report_fatal_error(ErrorMessage);
198 |   }
199 |   tooling::RefactoringTool Tool(*Compilations, SourcePaths);
200 |   ast_matchers::MatchFinder Finder;
201 |   FixCStrCall Callback(&Tool.getReplacements());
202 |   Finder.addMatcher(
203 |       constructExpr(
204 |           hasDeclaration(methodDecl(hasName(StringConstructor))),
205 |           argumentCountIs(2),
206 |           // The first argument must have the form x.c_str() or p->c_str()
207 |           // where the method is string::c_str().  We can use the copy
208 |           // constructor of string instead (or the compiler might share
209 |           // the string object).
210 |           hasArgument(
211 |               0, id("call", memberCallExpr(
212 |                                 callee(id("member", memberExpr())),
213 |                                 callee(methodDecl(hasName(StringCStrMethod))),
214 |                                 on(id("arg", expr()))))),
215 |           // The second argument is the alloc object which must not be
216 |           // present explicitly.
217 |           hasArgument(1, defaultArgExpr())),
218 |       &Callback);
219 |   Finder.addMatcher(
220 |       constructExpr(
221 |           // Implicit constructors of these classes are overloaded
222 |           // wrt. string types and they internally make a StringRef
223 |           // referring to the argument.  Passing a string directly to
224 |           // them is preferred to passing a char pointer.
225 |           hasDeclaration(
226 |               methodDecl(anyOf(hasName("::llvm::StringRef::StringRef"),
227 |                                hasName("::llvm::Twine::Twine")))),
228 |           argumentCountIs(1),
229 |           // The only argument must have the form x.c_str() or p->c_str()
230 |           // where the method is string::c_str().  StringRef also has
231 |           // a constructor from string which is more efficient (avoids
232 |           // strlen), so we can construct StringRef from the string
233 |           // directly.
234 |           hasArgument(
235 |               0, id("call", memberCallExpr(
236 |                                 callee(id("member", memberExpr())),
237 |                                 callee(methodDecl(hasName(StringCStrMethod))),
238 |                                 on(id("arg", expr())))))),
239 |       &Callback);
240 |   return Tool.runAndSave(newFrontendActionFactory(&Finder).get());
241 | }
242 | 


--------------------------------------------------------------------------------
/src_clang/experimental/try_matcher.cpp:
--------------------------------------------------------------------------------
  1 | //------------------------------------------------------------------------------
  2 | // Experimental sample; use at your own peril.
  3 | //
  4 | // Eli Bendersky (eliben@gmail.com)
  5 | // This code is in the public domain
  6 | //------------------------------------------------------------------------------
  7 | #include <set>
  8 | #include <string>
  9 | 
 10 | #include "clang/AST/AST.h"
 11 | #include "clang/AST/ASTConsumer.h"
 12 | #include "clang/AST/RecursiveASTVisitor.h"
 13 | #include "clang/ASTMatchers/ASTMatchFinder.h"
 14 | #include "clang/ASTMatchers/ASTMatchers.h"
 15 | #include "clang/Basic/SourceManager.h"
 16 | #include "clang/Frontend/FrontendActions.h"
 17 | #include "clang/Lex/Lexer.h"
 18 | #include "clang/Tooling/CommonOptionsParser.h"
 19 | #include "clang/Tooling/Tooling.h"
 20 | #include "llvm/Support/raw_ostream.h"
 21 | 
 22 | namespace clang {
 23 | namespace ast_matchers {
 24 | 
 25 | // AST matcher for names in a given set
 26 | AST_MATCHER_P(clang::NamedDecl, NameInSet, std::set<std::string>, nameset) {
 27 |   if (auto id = Node.getIdentifier()) {
 28 |     return nameset.count(id->getName().str()) > 0;
 29 |   }
 30 |   return false;
 31 | }
 32 | 
 33 | } // namespace ast_matchers
 34 | } // namespace clang
 35 | 
 36 | using namespace clang;
 37 | using namespace clang::ast_matchers;
 38 | using namespace clang::driver;
 39 | using namespace clang::tooling;
 40 | 
 41 | static llvm::cl::OptionCategory ToolingSampleCategory("Matcher Sample");
 42 | 
 43 | // string SourceRangeAsString(const clang::SourceRange& range,
 44 | // const clang::SourceManager& source_manager) {
 45 | // return "SourceRange [begin=" +
 46 | // ast_utils::AsString(range.getBegin().printToString(source_manager)) +
 47 | //",  end=" +
 48 | // ast_utils::AsString(range.getEnd().printToString(source_manager)) +
 49 | //"]";
 50 | //}
 51 | // The visitor approach
 52 | class MyASTVisitor : public RecursiveASTVisitor<MyASTVisitor> {
 53 | public:
 54 |   void FoundRealDecl(const NamedDecl *D) {
 55 |     llvm::errs() << "**== found real decl: " << D->getQualifiedNameAsString()
 56 |                  << "\n";
 57 |   }
 58 | 
 59 |   bool VisitCallExpr(CallExpr *E) {
 60 |     llvm::errs() << "I see a CallExpr\n";
 61 |     E->dump();
 62 | 
 63 |     Expr *callee = E->getCallee();
 64 | 
 65 |     if (ImplicitCastExpr *ica = llvm::dyn_cast<ImplicitCastExpr>(callee)) {
 66 |       callee = ica->getSubExpr();
 67 |     }
 68 | 
 69 |     if (DeclRefExpr *dref = llvm::dyn_cast<DeclRefExpr>(callee)) {
 70 |       llvm::errs() << "declref:\n";
 71 |       dref->dump();
 72 | 
 73 |       NamedDecl *d = dref->getFoundDecl();
 74 |       ASTContext &Context = d->getASTContext();
 75 |       SourceManager &SM = Context.getSourceManager();
 76 | 
 77 |       if (dref->hasQualifier()) {
 78 |         llvm::errs() << "  has qualifier in name.\n";
 79 |         NestedNameSpecifierLoc lc = dref->getQualifierLoc();
 80 | 
 81 |         llvm::errs() << "    begin loc: " << lc.getBeginLoc().printToString(SM)
 82 |                      << "\n";
 83 |         llvm::errs() << "    end loc: " << lc.getEndLoc().printToString(SM)
 84 |                      << "\n";
 85 |       }
 86 | 
 87 |       if (UsingShadowDecl *sh = llvm::dyn_cast<UsingShadowDecl>(d)) {
 88 |         NamedDecl *td = sh->getTargetDecl();
 89 |         FoundRealDecl(td);
 90 |         // d->dump();
 91 |       } else {
 92 |         FoundRealDecl(d);
 93 |         // d->dump();
 94 |       }
 95 |     } else if (UnresolvedLookupExpr *ule =
 96 |                    dyn_cast<UnresolvedLookupExpr>(callee)) {
 97 |       llvm::errs() << "unresolved\n";
 98 |       ASTContext *Context;
 99 |       SourceManager *SM;
100 |       for (const auto *d : ule->decls()) {
101 |         FoundRealDecl(d);
102 |         Context = &d->getASTContext();
103 |         SM = &Context->getSourceManager();
104 |       }
105 |       llvm::errs() << "    begin loc: " << ule->getLocStart().printToString(*SM)
106 |                    << "\n";
107 |       llvm::errs() << "    end loc: " << ule->getLocEnd().printToString(*SM)
108 |                    << "\n";
109 | 
110 |       NestedNameSpecifierLoc ll = ule->getQualifierLoc();
111 |       llvm::errs() << "    nested begin loc: "
112 |                    << ll.getBeginLoc().printToString(*SM) << "\n";
113 |       llvm::errs() << "    nested end loc: "
114 |                    << ll.getEndLoc().printToString(*SM) << "\n";
115 |     }
116 | 
117 |     return true;
118 |   }
119 |   // bool VisitIfStmt(IfStmt *s) {
120 |   // if (const BinaryOperator *BinOP =
121 |   // llvm::dyn_cast<BinaryOperator>(s->getCond())) {
122 |   // if (BinOP->getOpcode() == BO_EQ) {
123 |   // const Expr *LHS = BinOP->getLHS();
124 |   // if (const ImplicitCastExpr *Cast =
125 |   // llvm::dyn_cast<ImplicitCastExpr>(LHS)) {
126 |   // LHS = Cast->getSubExpr();
127 |   //}
128 | 
129 |   // if (const DeclRefExpr *DeclRef = llvm::dyn_cast<DeclRefExpr>(LHS)) {
130 |   // if (const VarDecl *Var =
131 |   // llvm::dyn_cast<VarDecl>(DeclRef->getDecl())) {
132 |   // if (Var->getType()->isPointerType()) {
133 |   ////Var->dump();
134 |   //}
135 |   //}
136 |   //}
137 |   //}
138 |   //}
139 |   // return true;
140 |   //}
141 | };
142 | 
143 | struct MyASTConsumer : public ASTConsumer {
144 |   bool HandleTopLevelDecl(DeclGroupRef DR) override {
145 |     for (DeclGroupRef::iterator b = DR.begin(), e = DR.end(); b != e; ++b) {
146 |       Visitor.TraverseDecl(*b);
147 |     }
148 |     return true;
149 |   }
150 | 
151 |   MyASTVisitor Visitor;
152 | };
153 | 
154 | struct MyFrontendAction : public ASTFrontendAction {
155 | public:
156 |   MyFrontendAction() {}
157 |   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
158 |                                                  StringRef file) override {
159 |     return llvm::make_unique<MyASTConsumer>();
160 |   }
161 | };
162 | 
163 | // The AST matcher approach
164 | struct IfStmtHandler : public MatchFinder::MatchCallback {
165 |   virtual void run(const MatchFinder::MatchResult &Result) {
166 |     const VarDecl *lhs = Result.Nodes.getNodeAs<VarDecl>("lhs");
167 |     lhs->dump();
168 |   }
169 | };
170 | 
171 | struct StuffDumper : public MatchFinder::MatchCallback {
172 |   virtual void run(const MatchFinder::MatchResult &Result) {
173 |     auto *d = Result.Nodes.getNodeAs<Decl>("stuff");
174 |     d->dump();
175 |   }
176 | };
177 | 
178 | struct RecordDumper : public MatchFinder::MatchCallback {
179 |   virtual void run(const MatchFinder::MatchResult &Result) {
180 |     auto *d = Result.Nodes.getNodeAs<TypeLoc>("stuff");
181 |     SourceLocation locstart = d->getLocStart();
182 |     llvm::errs() << "*\n";
183 |     llvm::errs() << " start: " << locstart.printToString(*Result.SourceManager)
184 |                  << "\n";
185 |     SourceLocation locend = d->getLocEnd();
186 |     llvm::errs() << " end: " << locend.printToString(*Result.SourceManager)
187 |                  << "\n";
188 |   }
189 | };
190 | 
191 | clang::Token GetTokenBeforeLocation(clang::SourceLocation loc,
192 |                                     const clang::ASTContext &ast_context) {
193 |   clang::Token token;
194 |   token.setKind(clang::tok::unknown);
195 |   clang::LangOptions lang_options = ast_context.getLangOpts();
196 |   const clang::SourceManager &source_manager = ast_context.getSourceManager();
197 |   clang::SourceLocation file_start_loc =
198 |       source_manager.getLocForStartOfFile(source_manager.getFileID(loc));
199 |   loc = loc.getLocWithOffset(-1);
200 |   while (loc != file_start_loc) {
201 |     loc = clang::Lexer::GetBeginningOfToken(loc, source_manager, lang_options);
202 |     if (!clang::Lexer::getRawToken(loc, token, source_manager, lang_options)) {
203 |       if (!token.is(clang::tok::comment)) {
204 |         break;
205 |       }
206 |     }
207 |     loc = loc.getLocWithOffset(-1);
208 |   }
209 |   return token;
210 | }
211 | 
212 | struct StuffExaminer : public MatchFinder::MatchCallback {
213 |   virtual void run(const MatchFinder::MatchResult &Result) {
214 |     auto *d = Result.Nodes.getNodeAs<CXXConstructorDecl>("stuff");
215 |     if (d) {
216 |       if (d->getNumCtorInitializers() > 0) {
217 |         const CXXCtorInitializer *firstinit = *d->init_begin();
218 |         if (!firstinit->isWritten()) {
219 |           llvm::errs() << "firstinit not written; skipping\n";
220 |           return;
221 |         }
222 |         if (firstinit->isBaseInitializer()) {
223 |           TypeLoc basetypeloc = firstinit->getBaseClassLoc();
224 |           llvm::errs() << "firstinit as base loc: "
225 |                        << basetypeloc.getBeginLoc().printToString(
226 |                               *Result.SourceManager)
227 |                        << "\n";
228 |         }
229 |         SourceLocation initloc = firstinit->getSourceLocation();
230 |         llvm::errs() << "firstinit loc: "
231 |                      << initloc.printToString(*Result.SourceManager) << "\n";
232 |         SourceRange initrange = firstinit->getSourceRange();
233 |         llvm::errs() << "firstinit range from "
234 |                      << initrange.getBegin().printToString(
235 |                             *Result.SourceManager)
236 |                      << "\n";
237 |         llvm::errs() << "firstinit range to "
238 |                      << initrange.getEnd().printToString(*Result.SourceManager)
239 |                      << "\n";
240 | 
241 |         SourceLocation start = firstinit->getLParenLoc();
242 |         llvm::errs() << "firstinit start: "
243 |                      << start.printToString(*Result.SourceManager) << "\n";
244 |         Token tok_id = GetTokenBeforeLocation(start, *Result.Context);
245 |         llvm::errs() << "  tok_id: "
246 |                      << tok_id.getLocation().printToString(
247 |                             *Result.SourceManager)
248 |                      << "\n";
249 |         Token tok_colon =
250 |             GetTokenBeforeLocation(tok_id.getLocation(), *Result.Context);
251 |         llvm::errs() << "  tok_colon: "
252 |                      << tok_colon.getLocation().printToString(
253 |                             *Result.SourceManager)
254 |                      << "\n";
255 | 
256 |         const CXXCtorInitializer *lastinit = *d->init_rbegin();
257 |         SourceLocation end = lastinit->getRParenLoc();
258 |         llvm::errs() << "lastinit end: "
259 |                      << end.printToString(*Result.SourceManager) << "\n";
260 |         // init->getInit()->dump();
261 |       }
262 |     }
263 |   }
264 | };
265 | 
266 | int main(int argc, const char **argv) {
267 |   CommonOptionsParser op(argc, argv, ToolingSampleCategory);
268 |   ClangTool Tool(op.getCompilations(), op.getSourcePathList());
269 | 
270 |   // Set up AST matcher callbacks.
271 |   IfStmtHandler HandlerForIf;
272 |   StuffDumper HandlerForStuff;
273 |   StuffExaminer HandlerExaminer;
274 | 
275 |   MatchFinder Finder;
276 |   const TypeMatcher AnyType = anything();
277 | 
278 |   // Find an 'if' expression with a '==' comparison, the left-hand-side of which
279 |   // is a variable of pointer type.
280 |   // Finder.addMatcher(
281 |   // ifStmt(hasCondition(binaryOperator(
282 |   // hasOperatorName("=="),
283 |   // hasLHS(ignoringParenImpCasts(declRefExpr(
284 |   // to(varDecl(hasType(pointsTo(AnyType))).bind("lhs")))))))),
285 |   //&HandlerForIf);
286 | 
287 |   // Match a namespace named Vroom
288 |   // Finder.addMatcher(
289 |   // namespaceDecl(hasName("Vroom")).bind("stuff"),
290 |   //&HandlerForStuff);
291 | 
292 |   // Match all function declarations in namespace Vroom
293 |   // Finder.addMatcher(
294 |   // functionDecl(hasAncestor(namespaceDecl(hasName("Vroom")))).bind("stuff"),
295 |   //&HandlerForStuff);
296 | 
297 |   std::set<std::string> nameset{"foo2", "bar3", "kwa4"};
298 | 
299 |   // all functions with names from nameset and in namespace Vroom
300 |   // Finder.addMatcher(functionDecl(NameInSet(nameset),
301 |   // hasAncestor(namespaceDecl(hasName("Vroom"))),
302 |   // unless(methodDecl()))
303 |   //.bind("stuff"),
304 |   //&HandlerForStuff);
305 | 
306 |   // All using declarations for name 'bolly'
307 |   // Finder.addMatcher(
308 |   // usingDecl(hasAnyUsingShadowDecl(hasName("bolly"))).bind("stuff"),
309 |   //&HandlerForStuff);
310 | 
311 |   // Finder.addMatcher(functionDecl().bind("stuff"), &HandlerExaminer);
312 |   // Finder.addMatcher(
313 |   // constructorDecl(hasAnyConstructorInitializer(withInitializer(
314 |   // callExpr(callee(functionDecl(NameInSet(nameset)))))))
315 |   //.bind("stuff"),
316 |   //&HandlerForStuff);
317 |   //
318 |   RecordDumper HandlerForRecords;
319 | 
320 |   Finder.addMatcher(loc(templateSpecializationType(
321 |                             hasDeclaration(namedDecl(hasName("Frob::Homer")))))
322 |                         .bind("stuff"),
323 |                     &HandlerForRecords);
324 | 
325 |   // DeclarationMatcher ClassHomer = recordDecl(hasName("Homer"));
326 |   // Finder.addMatcher(varDecl(hasType(ClassHomer)).bind("stuff"),
327 |   //&HandlerForRecords);
328 | 
329 |   llvm::outs() << "Running tool with RecursiveASTVisitor\n";
330 |   Tool.run(newFrontendActionFactory<MyFrontendAction>().get());
331 | 
332 |   llvm::outs() << "Running tool with AST matchers\n";
333 |   Tool.run(newFrontendActionFactory(&Finder).get());
334 | 
335 |   return 0;
336 | }
337 | 


--------------------------------------------------------------------------------
/tools/htmlize-ast-dump.py:
--------------------------------------------------------------------------------
  1 | #-------------------------------------------------------------------------------
  2 | # htmlize-ast-dump.py: Turn a Clang AST dump (-ast-dump) into cross-linked HTML.
  3 | #
  4 | # Run with --help for usage information.
  5 | #
  6 | # Note: this script requires Python 3.4; earlier versions of Python 3 should
  7 | # work if you install the enum34 module.
  8 | #
  9 | # Eli Bendersky (eliben@gmail.com)
 10 | # This code is in the public domain
 11 | #-------------------------------------------------------------------------------
 12 | import argparse
 13 | import enum
 14 | import html
 15 | import io
 16 | import json
 17 | import pprint
 18 | import re
 19 | import sys
 20 | 
 21 | HTML_OUTPUT_TEMPLATE = r'''
 22 | <html>
 23 | <head>
 24 |     <style>
 25 |     .main_area, .nav_area {{
 26 |         position: absolute;
 27 |         left: 0;
 28 |         right: 0;
 29 |     }}
 30 | 
 31 |     .main_area {{
 32 |         top: 0;
 33 |         height: 75%;
 34 |         overflow: scroll;
 35 |         background-color: black;
 36 |         white-space: nowrap;
 37 |         padding-left: 10px;
 38 |     }}
 39 | 
 40 |     .nav_area {{
 41 |         bottom: 0;
 42 |         height: 25%;
 43 |         overflow: scroll;
 44 |         background-color: #131313;
 45 |     }}
 46 | 
 47 |     #nav_title {{
 48 |         margin-left: auto;
 49 |         margin-right: auto;
 50 |         width: 200px;
 51 |         font-weight: bold;
 52 |         color: white;
 53 |         font-size: 140%;
 54 |     }}
 55 | 
 56 |     #nav_contents {{
 57 |         font-family: Consolas,monospace;
 58 |         font-size: 80%;
 59 |         color: #AAAAAA;
 60 |         padding: 10px;
 61 |     }}
 62 | 
 63 |     .my-pre {{
 64 |         line-height: 0.8;
 65 |         padding: 0px 0px;
 66 |         font-family: Consolas,monospace;
 67 |         font-size: 80%;
 68 |     }}
 69 | 
 70 |     a:link {{
 71 |         text-decoration: underline;
 72 |         color: inherit;
 73 |     }}
 74 | 
 75 |     a:visited {{
 76 |         text-decoration: underline;
 77 |         color: inherit;
 78 |     }}
 79 | 
 80 |     a:hover {{
 81 |         text-decoration: underline;
 82 |         color: #FFFFFF;
 83 |     }}
 84 | 
 85 |     a:active {{
 86 |         text-decoration: underline;
 87 |         color: #FFFFFF;
 88 |     }}
 89 | 
 90 |     .ansi-bold {{
 91 |         font-weight: bold;
 92 |         white-space: pre;
 93 |     }}
 94 | 
 95 |     .ansi-black {{
 96 |         color: #000000;
 97 |         white-space: pre;
 98 |     }}
 99 | 
100 |     .ansi-red {{
101 |         color: #d23737;
102 |         white-space: pre;
103 |     }}
104 | 
105 |     .ansi-green {{
106 |         color: #17b217;
107 |         white-space: pre;
108 |     }}
109 | 
110 |     .ansi-yellow {{
111 |         color: #b26717;
112 |         white-space: pre;
113 |     }}
114 | 
115 |     .ansi-blue {{
116 |         color: #2727c2;
117 |         white-space: pre;
118 |     }}
119 | 
120 |     .ansi-magenta {{
121 |         color: #b217b2;
122 |         white-space: pre;
123 |     }}
124 | 
125 |     .ansi-cyan {{
126 |         color: #17b2b2;
127 |         white-space: pre;
128 |     }}
129 | 
130 |     .ansi-white {{
131 |         color: #f2f2f2;
132 |         white-space: pre;
133 |     }}
134 |     </style>
135 | 
136 | </head>
137 | <body>
138 | <div class="main_area">
139 |     <pre class="my-pre">{lines}
140 |     </pre>
141 | </div>
142 | <div class="nav_area">
143 |     <div id="nav_contents">[Click on node address for cross-reference]</div>
144 | </div>
145 | <!-- Javascript -->
146 | <script type="text/javascript">
147 |     var nav_data = {nav_data};
148 | {js_code}
149 | </script>
150 | </body>
151 | </html>
152 | '''
153 | 
154 | JS_CODE = r'''
155 |     MakeAnchorLink = function(addr) {
156 |         anchorname = 'anchor_' + addr
157 |         return '<a href="#' + anchorname + '">' + addr + '</a>'
158 |     }
159 | 
160 |     OnAnchorClick = function(elem_id) {
161 |         var nav_entry = nav_data[elem_id];
162 | 
163 |         var contents = '';
164 |         contents += nav_entry['name'] + ' ' + nav_entry['id'];
165 |         contents += '<ul>\n';
166 | 
167 |         parent_id = nav_entry['parent'];
168 | 
169 |         if (parent_id === null) {
170 |             contents += '<li>Parent: none</li>\n';
171 |         } else {
172 |             parent_name = nav_data[parent_id]['name']
173 |             contents += '<li>Parent: ' + parent_name + ' ' +
174 |                         MakeAnchorLink(parent_id) + '</li>\n';
175 |         }
176 | 
177 |         contents += '<li>Children:'
178 | 
179 |         if (nav_entry['children'].length == 0) {
180 |             contents += 'none</li>'
181 |         } else {
182 |             contents += '\n<ul>\n'
183 |             for (var i = 0; i < nav_entry['children'].length; i++) {
184 |                 child_id = nav_entry['children'][i];
185 |                 child_name = nav_data[child_id]['name'];
186 |                 contents += '<li>' + child_name + ' ' +
187 |                             MakeAnchorLink(child_id) + '</li>\n';
188 |             }
189 |             contents += '</ul>\n'
190 |         }
191 | 
192 |         contents += '<li>Users:'
193 | 
194 |         if (nav_entry['users'].length == 0) {
195 |             contents += 'none</li>'
196 |         } else {
197 |             contents += '\n<ul>\n'
198 |             for (var i = 0; i < nav_entry['users'].length; i++) {
199 |                 user_id = nav_entry['users'][i];
200 |                 user_name = nav_data[user_id]['name'];
201 |                 contents += '<li>' + user_name + ' ' +
202 |                             MakeAnchorLink(user_id) + '</li>\n';
203 |             }
204 |             contents += '</ul>\n'
205 |         }
206 | 
207 |         document.getElementById('nav_contents').innerHTML = contents;
208 |     }
209 | '''
210 | 
211 | SPAN_TEMPLATE = r'<span class="{klass}">{text}</span>'
212 | 
213 | 
214 | class Color(enum.Enum):
215 |     """Colors with values corresponding to the ANSI codes.
216 |     """
217 |     BLACK = 30
218 |     RED = 31
219 |     GREEN = 32
220 |     YELLOW = 33
221 |     BLUE = 34
222 |     MAGENTA = 35
223 |     CYAN = 36
224 |     WHITE = 37
225 | 
226 | 
227 | # Input is broken to tokens. A token is a piece of text with the style that
228 | # applies to it. The text is decoded from binary to a string.
229 | class Token:
230 |     def __init__(self, text, style):
231 |         self.text = text.decode('ascii')
232 |         self.style = style
233 | 
234 |     def __repr__(self):
235 |         return 'Token<text={}, style={}>'.format(self.text, self.style)
236 | 
237 | 
238 | class Style:
239 |     def __init__(self, color=Color.WHITE, bold=False):
240 |         self.color = color
241 |         self.bold = bold
242 | 
243 |     def __repr__(self):
244 |         return 'Style<color={}, bold={}>'.format(self.color, self.bold)
245 | 
246 | 
247 | ANSI_PATTERN = re.compile(rb'\x1b\[([^m]+)m')
248 | 
249 | 
250 | def tokenize_line(line):
251 |     """Produce (yield) a stream of tokens from an input line.
252 |     """
253 |     # The end pos of the last pattern match.
254 |     last_end = 0
255 | 
256 |     # Current style
257 |     cur_style = Style()
258 | 
259 |     for match in ANSI_PATTERN.finditer(line):
260 |         preceding_text = line[last_end:match.start()]
261 |         yield Token(preceding_text, cur_style)
262 |         last_end = match.end()
263 | 
264 |         # Set the current style according to the ANSI code in the match.
265 |         for ansi_code in (int(c) for c in match.group(1).split(b';')):
266 |             if ansi_code == 0:
267 |                 # Reset
268 |                 cur_style = Style()
269 |             elif ansi_code == 1:
270 |                 cur_style.bold = True
271 |             else:
272 |                 # Color code. Obtain from Color enum. This will bomb if the
273 |                 # color code is invalid.
274 |                 cur_style.color = Color(ansi_code)
275 | 
276 |     leftover_text = line[last_end:]
277 |     yield Token(leftover_text, cur_style)
278 | 
279 | 
280 | # Link injections happens on HTML level - everything is a string now.
281 | ADDR_PATTERN = re.compile(r'0x[0-9a-fA-F]+')
282 | 
283 | 
284 | def make_anchor_link(addr, link_text):
285 |     anchorname = 'anchor_' + addr
286 |     return '<a href="#' + anchorname + '">' + link_text + '</a>'
287 | 
288 | 
289 | def make_anchor_target(addr):
290 |     anchorname = 'anchor_' + addr
291 |     return '<a id="' + anchorname + '"></a>'
292 | 
293 | 
294 | def inject_links(html_line_chunks):
295 |     first_addr = True
296 |     for i, chunk in enumerate(html_line_chunks):
297 |         match = ADDR_PATTERN.search(chunk)
298 |         if match:
299 |             addr = match.group()
300 |             if first_addr:
301 |                 # The first address encountered in the line is the address of
302 |                 # the node the line describes. This becomes a link anchor.
303 |                 #print(tok.text[match.start():match.end()], file=sys.stderr)
304 |                 html_line_chunks[i] = (
305 |                     chunk[:match.start()] +
306 |                     make_anchor_target(addr) +
307 |                     '<a onclick="OnAnchorClick(\'' + addr +
308 |                     '\');" href="#javascript:void(0)">' +
309 |                     chunk[match.start():] + '</a>')
310 |                 first_addr = False
311 |             else:
312 |                 # All other addresses refer to other nodes. These become links
313 |                 # to anchors.
314 |                 html_line_chunks[i] = (
315 |                     chunk[:match.start()] +
316 |                     make_anchor_link(addr, chunk[match.start():match.end()]) +
317 |                     chunk[match.end():])
318 | 
319 | 
320 | def analyze_line(tokens):
321 |     """Analyzes the given line (a list of tokens).
322 | 
323 |     Returns the tuple: <id>, <name>, <nesting level>, [<used id>...]
324 |     """
325 |     assert(len(tokens) > 2)
326 | 
327 |     # The top-level TranslationUnitDecl node has no nesting
328 |     if tokens[1].text.startswith('Translation'):
329 |         nesting = ''
330 |         itok = 1
331 |     else:
332 |         nesting = tokens[1].text
333 |         itok = 2
334 | 
335 |     # The name is a concat of the following non-empty tokens, until something
336 |     # that looks like the ID is encountered, or the line ends.
337 |     name_parts = []
338 |     while itok < len(tokens):
339 |         t = tokens[itok].text.strip()
340 |         if len(t) > 0:
341 |             if ADDR_PATTERN.match(t):
342 |                 # Found an ID; bail out
343 |                 break
344 |             else:
345 |                 # Part of the name
346 |                 name_parts.append(t)
347 |         itok += 1
348 |     name = ' '.join(name_parts)
349 | 
350 |     # Here itok is either past the end of the list, or it points to the ID.
351 |     id = tokens[itok].text.strip() if itok < len(tokens) else ''
352 |     itok += 1
353 | 
354 |     # Gather all uses
355 |     uses = []
356 |     while itok < len(tokens):
357 |         t = tokens[itok].text.strip()
358 |         if ADDR_PATTERN.match(t):
359 |             uses.append(t)
360 |         itok += 1
361 | 
362 |     nesting_level = len(nesting)
363 |     return id, name, nesting_level, uses
364 | 
365 | 
366 | def prepare_nav_data(line_info):
367 |     """Given a list of tuples from analyze_line, prepares navigation data.
368 | 
369 |     Navigation data is a dictionary mapping an id to its children ids, paren id
370 |     and user ids.
371 | 
372 |     It's important for line_info to be in the order gathered from the input. The
373 |     order is essential for determining parent/child relationships.
374 |     """
375 |     # ZZZ: in the end, add 'users' fields...
376 |     nav_data = {}
377 |     def new_data_entry(line_entry):
378 |         """Create a new entry with empty parent and child info."""
379 |         nonlocal nav_data
380 |         id, name, nesting_level, uselist = line_entry
381 |         nav_data[id] = {'id': id, 'name': name,
382 |                         'uses': uselist, 'users': [],
383 |                         'nesting_level': nesting_level,
384 |                         'parent': None, 'children': []}
385 |         return nav_data[id]
386 | 
387 |     # Keep a stack of parents. The topmost parent on the stack is the one
388 |     # collecting the current children, and their parent ID is mapped to it. The
389 |     # stack is popped when the nesting level decreases (popped until the topmost
390 |     # parent has a lower nesting level). Every entry is eventually pushed onto
391 |     # the stack because it may have children.
392 |     assert len(line_info) > 0
393 |     assert line_info[0][2] == 0, "Expect top-level entry at nesting level 0"
394 | 
395 |     # Initialize the parent stack to the first entry
396 |     parent_stack = [new_data_entry(line_info[0])]
397 | 
398 |     for line_entry in line_info[1:]:
399 |         data_entry = new_data_entry(line_entry)
400 | 
401 |         # Pop the stack until the topmost entry is a suitable parent for this
402 |         # one.
403 |         while parent_stack[-1]['nesting_level'] >= data_entry['nesting_level']:
404 |             # Note: no entry except the toplevel has nesting 0, so this will
405 |             # always terminate with at most 1 entry remaining on the stack.
406 |             parent_stack.pop()
407 | 
408 |         # Now parent_stack[-1] is the parent of this entry. Update the entries
409 |         # accordingly.
410 |         data_entry['parent'] = parent_stack[-1]['id']
411 |         parent_stack[-1]['children'].append(data_entry['id'])
412 | 
413 |         # At this point, we push the current entry onto the stack.
414 |         parent_stack.append(data_entry)
415 | 
416 |     # Finally, add 'users' fields to all entries. This is an inversion of 'uses'
417 |     for id, entry in nav_data.items():
418 |         for used_id in entry['uses']:
419 |             if used_id in nav_data:
420 |                 nav_data[used_id]['users'].append(id)
421 | 
422 |     return nav_data
423 | 
424 | 
425 | def htmlize(input):
426 |     """HTML-ize the input text, producing output.
427 | 
428 |     input: stream / file-like object with textual AST dump.
429 |     Returns a string with HTML-ized dump.
430 |     """
431 |     html_lines = []
432 | 
433 |     # collected list of line analysis info
434 |     line_info = []
435 | 
436 |     for text_line in input:
437 |         html_line_chunks = []
438 |         tokens = list(tokenize_line(text_line))
439 |         line_info.append(analyze_line(tokens))
440 |         for tok in tokens:
441 |             style = tok.style
442 |             klass = 'ansi-{}'.format(style.color.name.lower())
443 |             if style.bold:
444 |                 klass += ' ansi-bold'
445 |             html_line_chunks.append(SPAN_TEMPLATE.format(
446 |                     klass=klass,
447 |                     text=html.escape(tok.text)))
448 |         html_line_chunks.append('<br/>')
449 |         inject_links(html_line_chunks)
450 |         html_lines.append(''.join(html_line_chunks))
451 | 
452 |     nav_data = prepare_nav_data(line_info)
453 | 
454 |     return HTML_OUTPUT_TEMPLATE.format(lines='\n'.join(html_lines),
455 |                                        nav_data=json.dumps(nav_data),
456 |                                        js_code=JS_CODE)
457 | 
458 | 
459 | def main():
460 |     argparser = argparse.ArgumentParser(
461 |         description='HTML output is emitted to stdout')
462 |     argparser.add_argument('dump_file',
463 |                            help='AST dump file, "-" for reading from stdin')
464 |     args = argparser.parse_args()
465 | 
466 |     try:
467 |         # Argh: it would be nice to use argparse's FileType to do this
468 |         # automatically, but unfortunately it's broken for binary mode
469 |         # (http://bugs.python.org/issue14156)
470 |         input_stream = (open(sys.argv[1], 'rb') if args.dump_file != '-' else
471 |                         io.BufferedReader(sys.stdin.buffer))
472 |         print(htmlize(input_stream))
473 |         #tokens = list(tokenize_line(l) for l in input_stream)
474 |         #print(list(tokens[0]))
475 |     finally:
476 |         input_stream.close()
477 | 
478 | 
479 | if __name__ == '__main__':
480 |     main()
481 | 


--------------------------------------------------------------------------------