├── src ├── Release+Asserts │ ├── .dir │ ├── Cast.o │ ├── GEP.o │ ├── test.o │ ├── Power.o │ ├── ArrayName.o │ ├── LoopDepth.o │ ├── Loop_II.o │ ├── MemOpNum.o │ ├── Resource.o │ ├── SetPragma.o │ ├── UpdateMem.o │ ├── Dataflow_II.o │ ├── FindLatency.o │ ├── Function_II.o │ ├── InstLibrary.o │ ├── LoopLatency.o │ ├── Reschedule.o │ ├── LoopInterface.o │ ├── PartitionNum.o │ ├── SetParameter.o │ ├── ComputeFixedPath.o │ ├── FunctionLatency.o │ ├── LoopUnrollFactor.o │ ├── PartitionFactor.o │ ├── ComputeCriticalPath.o │ ├── ComputeMemLatency.o │ ├── EvaluateDependency.o │ ├── Power.d │ ├── GEP.d │ ├── Cast.d │ ├── ArrayName.d │ ├── LoopDepth.d │ ├── SetPragma.d │ └── ComputeFixedPath.d ├── Makefile ├── LoopDepth.h ├── InstLibrary.h ├── PartitionFactor.h ├── Power.h ├── Cast.h ├── ArrayName.h ├── Dataflow_II.h ├── LoopInterface.h ├── Constant.h ├── EvaluateDependency.h ├── LoopUnrollFactor.h ├── MemOpNum.h ├── PartitionNum.h ├── GEP.h ├── SetParameter.h ├── Cast.cpp ├── SetPragma.h ├── LoopDepth.cpp ├── FunctionLatency.h ├── Loop_II.h ├── Function_II.h ├── PartitionFactor.cpp ├── FindLatency.h ├── UpdateMem.h ├── LoopLatency.h ├── Power.cpp ├── ComputeFixedPath.h ├── Resource.h ├── LoopInterface.cpp ├── ArrayName.cpp ├── ComputeMemLatency.h ├── ComputeCriticalPath.h ├── Reschedule.h ├── LoopUnrollFactor.cpp ├── test.h ├── EvaluateDependency.cpp ├── Dataflow_II.cpp ├── Library.h ├── FindLatency.cpp ├── MemOpNum.cpp ├── InstLibrary.cpp └── UpdateMem.cpp ├── cfg ├── bicg.png └── gemm.png ├── runMyPro.sh ├── test_c ├── utilities │ ├── papi_counters.list │ ├── benchmark_list │ ├── clean.pl │ ├── run-all.pl │ ├── create_cpped_version.pl │ ├── makefile-gen.pl │ ├── polybench.spec │ ├── template-for-new-benchmark.c │ ├── time_benchmark.sh │ ├── header-gen.pl │ └── polybench.R ├── bicg │ ├── bicg.c │ ├── bicg.h │ └── main.c └── gemm │ ├── gemm.c │ ├── gemm.h │ └── main.c ├── .project ├── CMakeLists.txt ├── test ├── bicg.ll └── gemm.ll └── README.md /src/Release+Asserts/.dir: -------------------------------------------------------------------------------- 1 | Sun Oct 1 15:02:55 CST 2017 2 | -------------------------------------------------------------------------------- /cfg/bicg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/cfg/bicg.png -------------------------------------------------------------------------------- /cfg/gemm.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/cfg/gemm.png -------------------------------------------------------------------------------- /src/Release+Asserts/Cast.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Cast.o -------------------------------------------------------------------------------- /src/Release+Asserts/GEP.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/GEP.o -------------------------------------------------------------------------------- /src/Release+Asserts/test.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/test.o -------------------------------------------------------------------------------- /src/Release+Asserts/Power.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Power.o -------------------------------------------------------------------------------- /src/Release+Asserts/ArrayName.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/ArrayName.o -------------------------------------------------------------------------------- /src/Release+Asserts/LoopDepth.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/LoopDepth.o -------------------------------------------------------------------------------- /src/Release+Asserts/Loop_II.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Loop_II.o -------------------------------------------------------------------------------- /src/Release+Asserts/MemOpNum.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/MemOpNum.o -------------------------------------------------------------------------------- /src/Release+Asserts/Resource.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Resource.o -------------------------------------------------------------------------------- /src/Release+Asserts/SetPragma.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/SetPragma.o -------------------------------------------------------------------------------- /src/Release+Asserts/UpdateMem.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/UpdateMem.o -------------------------------------------------------------------------------- /src/Release+Asserts/Dataflow_II.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Dataflow_II.o -------------------------------------------------------------------------------- /src/Release+Asserts/FindLatency.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/FindLatency.o -------------------------------------------------------------------------------- /src/Release+Asserts/Function_II.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Function_II.o -------------------------------------------------------------------------------- /src/Release+Asserts/InstLibrary.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/InstLibrary.o -------------------------------------------------------------------------------- /src/Release+Asserts/LoopLatency.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/LoopLatency.o -------------------------------------------------------------------------------- /src/Release+Asserts/Reschedule.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/Reschedule.o -------------------------------------------------------------------------------- /src/Release+Asserts/LoopInterface.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/LoopInterface.o -------------------------------------------------------------------------------- /src/Release+Asserts/PartitionNum.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/PartitionNum.o -------------------------------------------------------------------------------- /src/Release+Asserts/SetParameter.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/SetParameter.o -------------------------------------------------------------------------------- /src/Release+Asserts/ComputeFixedPath.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/ComputeFixedPath.o -------------------------------------------------------------------------------- /src/Release+Asserts/FunctionLatency.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/FunctionLatency.o -------------------------------------------------------------------------------- /src/Release+Asserts/LoopUnrollFactor.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/LoopUnrollFactor.o -------------------------------------------------------------------------------- /src/Release+Asserts/PartitionFactor.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/PartitionFactor.o -------------------------------------------------------------------------------- /src/Release+Asserts/ComputeCriticalPath.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/ComputeCriticalPath.o -------------------------------------------------------------------------------- /src/Release+Asserts/ComputeMemLatency.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/ComputeMemLatency.o -------------------------------------------------------------------------------- /src/Release+Asserts/EvaluateDependency.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/zjru/COMBA/HEAD/src/Release+Asserts/EvaluateDependency.o -------------------------------------------------------------------------------- /runMyPro.sh: -------------------------------------------------------------------------------- 1 | #! /bin/bash 2 | rm -rf /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts 3 | cd ./src 4 | make 5 | -------------------------------------------------------------------------------- /src/Makefile: -------------------------------------------------------------------------------- 1 | LEVEL = ../../../.. 2 | LIBRARYNAME = LLVMTest 3 | LOADABLE_MODULE = 1 4 | USEDLIBS = 5 | 6 | include $(LEVEL)/Makefile.common 7 | -------------------------------------------------------------------------------- /test_c/utilities/papi_counters.list: -------------------------------------------------------------------------------- 1 | // Counters must be delimited with ',' including the last one. 2 | // C/C++ comments are allowed. 3 | // Both native and standard PAPI events are supported. 4 | "PAPI_TOT_CYC", 5 | "L1D:REPL", 6 | -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | comba 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/Release+Asserts/Power.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/Power.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/Power.d: \ 3 | Power.cpp Constant.h Power.h 4 | 5 | Constant.h: 6 | 7 | Power.h: 8 | -------------------------------------------------------------------------------- /src/LoopDepth.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef LOOPDEPTH_H_ 15 | #define LOOPDEPTH_H_ 16 | 17 | #include "test.h" 18 | 19 | int nested_loop_depth_for_loop(Loop* L); 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /src/InstLibrary.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef INSTLIBRARY_H_ 15 | #define INSTLIBRARY_H_ 16 | 17 | #include "test.h" 18 | 19 | float inst_latency_in_library(Instruction *inst); 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /src/PartitionFactor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef PARTITIONFACTOR_H_ 15 | #define PARTITIONFACTOR_H_ 16 | 17 | #include "test.h" 18 | 19 | int partition_factor(Instruction *inst); 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /src/Power.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef POWER_H_ 15 | #define POWER_H_ 16 | 17 | bool is_power_of_two(int n); 18 | int closest_bound_power_two(int n); 19 | int get_power_of_two(int n); 20 | 21 | #endif 22 | 23 | -------------------------------------------------------------------------------- /src/Cast.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef CAST_H_ 15 | #define CAST_H_ 16 | 17 | #include "test.h" 18 | 19 | bool inst_is_cast(Instruction *inst); 20 | Instruction *get_cast_inst(Instruction *inst); 21 | 22 | #endif 23 | -------------------------------------------------------------------------------- /src/ArrayName.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | #ifndef ARRAYNAME_H_ 14 | #define ARRAYNAME_H_ 15 | 16 | #include "test.h" 17 | 18 | Value *check_PHI_operand(PHINode *phi); 19 | Value *get_array_name(Instruction *inst); 20 | 21 | #endif 22 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_llvm_loadable_module( LLVMTest 2 | test.cpp 3 | ArrayName.cpp 4 | Cast.cpp 5 | ComputeCriticalPath.cpp 6 | ComputeFixedPath.cpp 7 | ComputeMemLatency.cpp 8 | EvaluateDependency.cpp 9 | FindLatency.cpp 10 | GEP.cpp 11 | InstLibrary.cpp 12 | Loop_II.cpp 13 | LoopDepth.cpp 14 | LoopLatency.cpp 15 | LoopUnrollFactor.cpp 16 | MemOpNum.cpp 17 | PartitionFactor.cpp 18 | PartitionNum.cpp 19 | Power.cpp 20 | Reschedule.cpp 21 | UpdateMem.cpp 22 | ) 23 | -------------------------------------------------------------------------------- /src/Dataflow_II.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef DATAFLOW_II_H_ 15 | #define DATAFLOW_II_H_ 16 | 17 | #include "test.h" 18 | 19 | bool check_dataflow(Function *F, LoopInfo* LI); 20 | int compute_dataflow_II(Function *F, LoopInfo* LI); 21 | 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /src/LoopInterface.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef LOOPINTERFACE_H_ 15 | #define LOOPINTERFACE_H_ 16 | 17 | #include "test.h" 18 | 19 | void get_loop_input(Loop *L, std::vector &loop_read); 20 | void get_loop_output(Loop *L, std::vector &loop_write); 21 | 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /src/Constant.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef CONSTANT_H_ 15 | #define CONSTANT_H_ 16 | 17 | 18 | #define inf 1<<30 19 | #define INSN_NUM_MUX 200 20 | #define INSN_NUM 1000 21 | 22 | #define port_num_read 2 23 | #define port_num_write_diff 2 24 | #define port_num_write_same 1 25 | 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /src/EvaluateDependency.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef EVALUATEDEPENDENCY_H_ 15 | #define EVALUATEDEPENDENCY_H_ 16 | 17 | #include "test.h" 18 | 19 | bool load_store_dependency(Instruction *inst_l, Instruction *inst_s); 20 | bool store_store_dependency(Instruction *inst_s1, Instruction *inst_s2); 21 | bool test_loop_carried_dependence(LoopInfo* LI, Loop *L); 22 | 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/LoopUnrollFactor.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef LOOPUNROLLFACTOR_H_ 15 | #define LOOPUNROLLFACTOR_H_ 16 | 17 | #include "test.h" 18 | 19 | int total_unroll_factor(Loop *L); 20 | bool unroll_loop_relation(Loop *L1, Loop *L2); 21 | int total_unroll_factor_ls(LoopInfo *LI, Loop *L, Instruction *inst); 22 | int total_unroll_factor_op(LoopInfo *LI, Loop *L, Instruction *inst); 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/MemOpNum.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef MEMOPNUM_H_ 15 | #define MEMOPNUM_H_ 16 | 17 | #include "test.h" 18 | 19 | int compute_BB_load_num(BasicBlock *itb, Instruction *inst); 20 | int compute_BB_store_num(BasicBlock *itb, Instruction *inst); 21 | int partition_mem_op_num(LoopInfo *LI, BasicBlock *bb, Instruction *inst); 22 | int compute_total_LS_num(LoopInfo* LI, Instruction *inst); 23 | 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /src/PartitionNum.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef PARTITIONNUM_H_ 15 | #define PARTITIONNUM_H_ 16 | 17 | #include "test.h" 18 | 19 | int get_bank_number(Instruction *inst); 20 | int compute_array_element_offset(Instruction *inst, BasicBlock *bb, int base_variable); 21 | int get_unroll_SameBank_num(BasicBlock *bb, Instruction *inst, Instruction *inst1, std::vector &array_element_counted); 22 | 23 | #endif 24 | -------------------------------------------------------------------------------- /src/GEP.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef GEP_H_ 15 | #define GEP_H_ 16 | 17 | #include "test.h" 18 | 19 | GetElementPtrInst *get_GEP(Instruction *inst); 20 | int compute_gep_operand(Value *op, bool second_iteration_flag, int compute_second); 21 | int get_phi_second(Loop *L, PHINode *PHI); 22 | PHINode *get_phi(Instruction *inst, PHINode *PHI); 23 | int get_gep_phi(GetElementPtrInst *gep, PHINode *PHI); 24 | 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/SetParameter.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef SETPARAMETER_H_ 15 | #define SETPARAMETER_H_ 16 | 17 | #include "test.h" 18 | 19 | 20 | void set_loop_map(Loop *L,Loop *parent,Loop *loop,std::map loop_index_tmp,std::vector *loop_index); 21 | void set_loop_index(Function *F, LoopInfo* LI, Loop *L,std::map &loop_index_tmp,std::vector *loop_index); 22 | void set_array_index(Module &M); 23 | void set_array_map(Module &M); 24 | void store_function_IO(Module &M); 25 | 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /test_c/bicg/bicg.c: -------------------------------------------------------------------------------- 1 | /** 2 | * This version is stamped on May 10, 2016 3 | * 4 | * Contact: 5 | * Louis-Noel Pouchet 6 | * Tomofumi Yuki 7 | * 8 | * Web address: http://polybench.sourceforge.net 9 | */ 10 | /* bicg.c: this file is part of PolyBench/C */ 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | #include "bicg.h" 18 | 19 | void kernel_bicg(int A[N][M], int s[M], int q[N], int p[M], int r[N]) 20 | { 21 | int i, j; 22 | int m=M; 23 | int n=N; 24 | kernel_bicg_label2:for (i = 0; i < n; i++) 25 | { 26 | kernel_bicg_label0:for (j = 0; j < m; j++) 27 | { 28 | s[j] = s[j] + r[i] * A[i][j]; 29 | q[i] = q[i] + A[i][j] * p[j]; 30 | } 31 | } 32 | 33 | } 34 | -------------------------------------------------------------------------------- /src/Cast.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "Cast.h" 15 | 16 | bool inst_is_cast(Instruction *inst) 17 | { 18 | unsigned opcode=inst->getOpcode(); 19 | if((opcode==Instruction::Trunc)||(opcode==Instruction::ZExt)||(opcode==Instruction::SExt)||(opcode==Instruction::FPTrunc)||(opcode==Instruction::FPExt)){ 20 | return true; 21 | } 22 | else{ 23 | return false; 24 | } 25 | 26 | } 27 | 28 | Instruction *get_cast_inst(Instruction *inst) 29 | { 30 | Instruction *op_inst=NULL; 31 | Value *op=inst->getOperand(0); 32 | op_inst=dyn_cast(op); 33 | return op_inst; 34 | } 35 | -------------------------------------------------------------------------------- /src/SetPragma.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef SETPRAGMA_H_ 15 | #define SETPRAGMA_H_ 16 | 17 | #include "test.h" 18 | 19 | void set_dataflow(Module &M); 20 | bool function_is_inline(Function *F); 21 | bool function_is_noinline(Function *F); 22 | bool has_subFn(Function *F); 23 | bool Fn_pipeline_modify(Function *F); 24 | void set_function_pipeline(Module &M); 25 | bool set_subFn_pipeline(Loop *L); 26 | void set_loop_counter_ul_pipeline(LoopInfo* LI, Function *F); 27 | void set_array_partition(Module &M); 28 | void keep_array_consistent(Function *callee, CallInst *call); 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/LoopDepth.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "LoopDepth.h" 15 | 16 | int nested_loop_depth_for_loop(Loop* L) 17 | { 18 | int counter_depth=0; 19 | std::vector subLoops=L->getSubLoops(); 20 | int subLoop_num = subLoops.size(); 21 | if(subLoops.empty()){ 22 | counter_depth += 1; 23 | } 24 | else{ 25 | int counter=0; 26 | for(int j=0;j &instr_index_loop, std::vector > *dependence_loop); 20 | void reorder_load(Function *F, std::map &load_order_buff); 21 | void store_complete_subloop(Loop *L, std::map &Complete_Loop_Index); 22 | void store_complete_loop(LoopInfo* LI, std::map &Complete_Loop_Index); 23 | Loop *get_top_loop(Loop *L); 24 | bool all_is_small(BasicBlock *bb, Instruction *inst); 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/Loop_II.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef LOOP_II_H_ 15 | #define LOOP_II_H_ 16 | 17 | #include "test.h" 18 | 19 | int compute_II(LoopInfo* LI, Loop* L, std::map &instr_index_loop, std::map &load_order_buff, std::vector > *dependence_loop); 20 | int find_array_offset(LoopInfo* LI, Instruction *inst); 21 | int find_distance(LoopInfo* LI, Instruction *inst_l, Instruction *inst_s); 22 | int find_max_rec_II(LoopInfo* LI, Loop *L, Instruction *inst, PHINode *phi, std::map &instr_index_loop, std::vector > *dependence_loop); 23 | int find_ResMII(LoopInfo* LI, Loop *L, std::map &load_order_buff); 24 | 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/Function_II.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef FUNCTION_II_H_ 15 | #define FUNCTION_II_H_ 16 | 17 | #include "test.h" 18 | 19 | int compute_Fn_II(Function *F, LoopInfo* LI,std::map &instr_index_loop, std::vector > *dependence_loop,std::vector > *function_arg_II); 20 | int find_Fn_ResMII(Function *F, LoopInfo* LI, std::vector > *function_arg_II); 21 | bool is_call_argument(CallInst *call, Value *arg); 22 | unsigned get_arg_number(CallInst *call, Value *arg); 23 | int find_Fns_ResMII(Function *F, LoopInfo* LI, std::map &instr_index_loop, std::vector > *dependence_loop,std::vector > *function_arg_II); 24 | 25 | 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /test_c/gemm/gemm.c: -------------------------------------------------------------------------------- 1 | /** 2 | * This version is stamped on May 10, 2016 3 | * 4 | * Contact: 5 | * Louis-Noel Pouchet 6 | * Tomofumi Yuki 7 | * 8 | * Web address: http://polybench.sourceforge.net 9 | */ 10 | /* gemm.c: this file is part of PolyBench/C */ 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | /* Include benchmark-specific header. */ 18 | #include "gemm.h" 19 | 20 | /* Main computational kernel. The whole function will be timed, 21 | including the call and return. */ 22 | void kernel_gemm(int C[NI][NJ], int A[NI][NK],int B[NK][NJ]) 23 | { 24 | int i, j, k; 25 | int alpha=3; 26 | int beta=2; 27 | int ni=NI; 28 | int nj=NJ; 29 | int nk=NK; 30 | kernel_gemm_label3:for (i = 0; i < ni; i++) { 31 | for (j = 0; j < nj; j++){ 32 | C[i][j] *= beta; 33 | } 34 | for (k = 0; k < nk; k++) { 35 | kernel_gemm_label1:for (j = 0; j < nj; j++){ 36 | C[i][j] += alpha * A[i][k] * B[k][j]; 37 | } 38 | } 39 | } 40 | 41 | } 42 | 43 | -------------------------------------------------------------------------------- /src/PartitionFactor.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "PartitionFactor.h" 15 | #include "ArrayName.h" 16 | 17 | 18 | int partition_factor(Instruction *inst) 19 | { 20 | int factor=1; 21 | Value *array_name=get_array_name(inst); 22 | if(array_number.count(array_name)){ 23 | int array_index=array_number[array_name]; 24 | int dim=array_dimension[array_index]; 25 | if(dim==1){ 26 | std::vector< std::pair >::iterator it = array_partition[array_index].begin(); 27 | factor=it->second; 28 | } 29 | else if(dim>1){ 30 | int fac=1; 31 | for(std::vector< std::pair >::iterator it= array_partition[array_index].begin(); it!=array_partition[array_index].end(); ++it){ 32 | fac=it->second; 33 | factor *=fac; 34 | } 35 | } 36 | else{ 37 | errs()<<"Dim is 0, wrong!\n"; 38 | } 39 | } 40 | return factor; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /src/FindLatency.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef FINDLATENCY_H_ 15 | #define FINDLATENCY_H_ 16 | 17 | #include "test.h" 18 | 19 | 20 | float find_latency_before_inst(Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 21 | float find_latency_after_inst(Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 22 | float find_latency(Instruction *inst_begin, Instruction *inst_end, std::map &instr_index_loop, std::vector > *dependence_loop); 23 | float get_inst_latency(Instruction *inst, std::map &instr_index_loop,std::vector > *dependence_loop); 24 | void set_inst_latency(Instruction *inst,float latency,std::map &instr_index_loop,std::vector > *dependence_loop); 25 | 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /test_c/utilities/benchmark_list: -------------------------------------------------------------------------------- 1 | ./datamining/correlation/correlation.c 2 | ./datamining/covariance/covariance.c 3 | ./linear-algebra/kernels/2mm/2mm.c 4 | ./linear-algebra/kernels/3mm/3mm.c 5 | ./linear-algebra/kernels/atax/atax.c 6 | ./linear-algebra/kernels/bicg/bicg.c 7 | ./linear-algebra/kernels/doitgen/doitgen.c 8 | ./linear-algebra/kernels/mvt/mvt.c 9 | ./linear-algebra/blas/gemm/gemm.c 10 | ./linear-algebra/blas/gemver/gemver.c 11 | ./linear-algebra/blas/gesummv/gesummv.c 12 | ./linear-algebra/blas/symm/symm.c 13 | ./linear-algebra/blas/syr2k/syr2k.c 14 | ./linear-algebra/blas/syrk/syrk.c 15 | ./linear-algebra/blas/trmm/trmm.c 16 | ./linear-algebra/solvers/cholesky/cholesky.c 17 | ./linear-algebra/solvers/durbin/durbin.c 18 | ./linear-algebra/solvers/gramschmidt/gramschmidt.c 19 | ./linear-algebra/solvers/lu/lu.c 20 | ./linear-algebra/solvers/ludcmp/ludcmp.c 21 | ./linear-algebra/solvers/trisolv/trisolv.c 22 | ./medley/deriche/deriche.c 23 | ./medley/floyd-warshall/floyd-warshall.c 24 | ./medley/nussinov/nussinov.c 25 | ./stencils/adi/adi.c 26 | ./stencils/fdtd-2d/fdtd-2d.c 27 | ./stencils/heat-3d/heat-3d.c 28 | ./stencils/jacobi-1d/jacobi-1d.c 29 | ./stencils/jacobi-2d/jacobi-2d.c 30 | ./stencils/seidel-2d/seidel-2d.c 31 | -------------------------------------------------------------------------------- /src/UpdateMem.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef UPDATEMEM_H_ 15 | #define UPDATEMEM_H_ 16 | 17 | #include "test.h" 18 | 19 | void complete_load_update(Loop *L1, Loop *L2, float latency,float latency_delta, unsigned index1,unsigned index2, Instruction* inst,std::vector > *dependence_loop); 20 | void update_load(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 21 | void replace_write_latency(int store_num1, int store_num2, unsigned index, Instruction *inst,std::vector > *dependence_loop); 22 | void complete_store_update(Loop *L1, Loop *L2, int store_num1, int store_num2, unsigned index, Instruction *inst, std::vector > *dependence_loop); 23 | void update_store(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 24 | 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /test_c/utilities/clean.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | # Visits every directory, calls make clean, and then removes the Makefile 4 | # 5 | # Written by Tomofumi Yuki, 11/21 2014 6 | # 7 | 8 | my $TARGET_DIR = "."; 9 | 10 | if ($#ARGV != 0) { 11 | printf("usage perl clean.pl target-dir\n"); 12 | exit(1); 13 | } 14 | 15 | 16 | 17 | if ($#ARGV == 0) { 18 | $TARGET_DIR = $ARGV[0]; 19 | } 20 | 21 | 22 | my @categories = ('linear-algebra/blas', 23 | 'linear-algebra/kernels', 24 | 'linear-algebra/solvers', 25 | 'datamining', 26 | 'stencils', 27 | 'medley'); 28 | 29 | 30 | foreach $cat (@categories) { 31 | my $target = $TARGET_DIR.'/'.$cat; 32 | opendir DIR, $target or die "directory $target not found.\n"; 33 | while (my $dir = readdir DIR) { 34 | next if ($dir=~'^\..*'); 35 | next if (!(-d $target.'/'.$dir)); 36 | 37 | my $targetDir = $target.'/'.$dir; 38 | my $command = "cd $targetDir; make clean; rm -f Makefile"; 39 | print($command."\n"); 40 | system($command); 41 | } 42 | 43 | closedir DIR; 44 | } 45 | 46 | my $cfgFile = $TARGET_DIR.'/'.'config.mk'; 47 | if (-e $cfgFile) { 48 | unlink $cfgFile; 49 | } 50 | 51 | -------------------------------------------------------------------------------- /src/LoopLatency.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef LOOPLATENCY_H_ 15 | #define LOOPLATENCY_H_ 16 | 17 | #include "test.h" 18 | 19 | bool test_loop_is_perfect(Loop* L); 20 | float pipeline_iteration_latency(LoopInfo* LI, Loop *L,int II, std::map &instr_index_loop, std::map &load_order_buff, std::vector > *dependence_loop); 21 | float perfect_pipeline_iteration_latency(LoopInfo* LI, Loop *L, int II, std::map &instr_index_loop,std::map &load_order_buff, std::vector > *dependence_loop); 22 | float compute_cycles_in_loop(LoopInfo* LI, Loop* L, std::map &load_order_buff); 23 | void Loop_insert(LoopInfo* LI, Loop *L, unsigned &index_loop, std::map &instr_index_loop, std::map &load_order_buff, std::vector > *dependence_loop, std::map > &inst_map_branch); 24 | 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/Power.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "Constant.h" 15 | #include "Power.h" 16 | 17 | bool is_power_of_two(int n) 18 | { 19 | if(n==0) 20 | return false; 21 | else if(n==1) 22 | return true; 23 | else if(n%2) 24 | return false; 25 | else 26 | return is_power_of_two(n/2); 27 | } 28 | 29 | int closest_bound_power_two(int n) 30 | { 31 | int m1=0; 32 | int m2=0; 33 | int m=0; 34 | if(n<0){ 35 | n=-n; 36 | } 37 | for(int i=n;i>0;--i){ 38 | bool is_power_two=is_power_of_two(i); 39 | if(is_power_two==true){ 40 | m1=i; 41 | break; 42 | } 43 | } 44 | for(int i=n;idelta_m2){ 54 | m=m2; 55 | } 56 | else{ 57 | m=m1; 58 | } 59 | return m; 60 | } 61 | 62 | int get_power_of_two(int n) 63 | { 64 | int power=1; 65 | if(n==1){ 66 | power=0; 67 | } 68 | else if(is_power_of_two(n)==true){ 69 | power+=get_power_of_two(n/2); 70 | } 71 | else{ 72 | n--; 73 | power=get_power_of_two(n); 74 | } 75 | return power; 76 | } 77 | -------------------------------------------------------------------------------- /test_c/utilities/run-all.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | # Visits every directory, calls make, and then executes the benchmark 4 | # (Designed for making sure every kernel compiles/runs after modifications) 5 | # 6 | # Written by Tomofumi Yuki, 01/15 2015 7 | # 8 | 9 | my $TARGET_DIR = "."; 10 | 11 | if ($#ARGV != 0 && $#ARGV != 1) { 12 | printf("usage perl run-all.pl target-dir [output-file]\n"); 13 | exit(1); 14 | } 15 | 16 | 17 | 18 | if ($#ARGV >= 0) { 19 | $TARGET_DIR = $ARGV[0]; 20 | } 21 | 22 | my $OUTFILE = ""; 23 | if ($#ARGV == 1) { 24 | $OUTFILE = $ARGV[1]; 25 | } 26 | 27 | 28 | my @categories = ('linear-algebra/blas', 29 | 'linear-algebra/kernels', 30 | 'linear-algebra/solvers', 31 | 'datamining', 32 | 'stencils', 33 | 'medley'); 34 | 35 | 36 | foreach $cat (@categories) { 37 | my $target = $TARGET_DIR.'/'.$cat; 38 | opendir DIR, $target or die "directory $target not found.\n"; 39 | while (my $dir = readdir DIR) { 40 | next if ($dir=~'^\..*'); 41 | next if (!(-d $target.'/'.$dir)); 42 | 43 | my $kernel = $dir; 44 | my $targetDir = $target.'/'.$dir; 45 | my $command = "cd $targetDir; make clean; make; ./$kernel"; 46 | $command .= " 2>> $OUTFILE" if ($OUTFILE ne ''); 47 | print($command."\n"); 48 | system($command); 49 | } 50 | 51 | closedir DIR; 52 | } 53 | 54 | -------------------------------------------------------------------------------- /src/ComputeFixedPath.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef COMPUTEFIXEDPATH_H_ 15 | #define COMPUTEFIXEDPATH_H_ 16 | 17 | #include "test.h" 18 | 19 | void loop_computeCP_gep_fixed_latency(Loop *L, Instruction *inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 20 | void loop_computeCP_fixed_latency(Loop *L, Instruction * inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 21 | void loop_computeCP_call_fixed_latency(Loop *L, Instruction *inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 22 | void loop_computeCP_phi_fixed_latency(Loop *L, Instruction *inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 23 | void update_fix_latency(Loop *L, Instruction *inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 24 | 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /src/Resource.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef RESOURCE_H_ 15 | #define RESOURCE_H_ 16 | 17 | #include "test.h" 18 | 19 | void inst_map_resource(Instruction *inst, bool &shareable_unit,std::map &inst_unit); 20 | void get_unit_resource(Instruction *inst, std::map &inst_unit, std::map &resource_usage,std::vector > *function_resource); 21 | void compute_resource(Instruction *inst,std::map &loop_resource, std::vector > *function_resource, std::map &inst_unit, std::map &scheduled_inst_unit, std::map &instr_index, std::vector > *dependence); 22 | bool loop_pipeline_is_set(Loop *L); 23 | Loop *get_pipelined_loop(Loop *L); 24 | void count_related_loops(Loop *L, std::map &Loop_counted); 25 | bool all_loop_unrolled(Loop *L); 26 | void compute_loop_resource(LoopInfo* LI, Loop *L,std::vector > *function_resource, std::map &loop_resource, std::map &load_buff,std::map &Loop_counted); 27 | void resource_accumulation(LoopInfo* LI,Function *F,std::vector > *function_resource, std::map &instr_index_loop, std::vector > *dependence_loop); 28 | void bram_accumulation(LoopInfo* LI,Function *F,std::vector > *function_resource); 29 | 30 | 31 | #endif 32 | -------------------------------------------------------------------------------- /test_c/utilities/create_cpped_version.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | # Creates C Pre-Processed Version 4 | # Additional arguments to the script are all passed to gcc. 5 | # At least the include path of polybench.h must be added. 6 | # 7 | # Written by Tomofumi Yuki, 01/14 2015 8 | # 9 | 10 | if ($#ARGV == -1) { 11 | printf("usage perl create-cpped-version.pl filename [cflags]\n"); 12 | exit(1); 13 | } 14 | 15 | my @CFLAGS = @ARGV; 16 | my $TARGET = shift @CFLAGS; 17 | 18 | my $TEMP_T = '.__poly_top.c'; 19 | my $TEMP_B = '.__poly_bottom.c'; 20 | my $TEMP_P = '.__poly_bottom.pp.c'; 21 | 22 | $TARGET =~ /([^\.\/]+)\.c$/; 23 | my $KERNEL = $1; 24 | $TARGET_DIR = substr $TARGET, 0, -length($KERNEL)-2; 25 | $TARGET_DIR = '.' if $TARGET_DIR eq ''; 26 | 27 | open FILE, $TARGET or die "Error opening $TARGET"; 28 | 29 | my $top; 30 | my $bottom; 31 | my $current = \$top; 32 | while () { 33 | my $line = $_; 34 | if ($line =~ /polybench\.h/) { 35 | $current = \$bottom; 36 | } 37 | $$current .= $line; 38 | } 39 | close FILE; 40 | 41 | &writeToFile($TEMP_T, $top); 42 | &writeToFile($TEMP_B, $bottom); 43 | 44 | my $ignoreLibs = "-D_STDLIB_H_ -D_STDIO_H_ -D_MATH_H_ -D_STRING_H_ -D_UNISTD_H_"; 45 | 46 | my $command = 'gcc -E '.$ignoreLibs.' '.$TEMP_B.' -I '.$TARGET_DIR.' '.join(" ", @CFLAGS).' 2>/dev/null > '.$TEMP_P; 47 | system($command); 48 | 49 | my $OUTFILE = $TARGET_DIR.'/'.$KERNEL.'.preproc.c'; 50 | system('cat '.$TEMP_T.' > '.$OUTFILE); 51 | system('echo "#include" >> '.$OUTFILE); 52 | $command = 'sed -e "s~'.$TEMP_B.'~'.$KERNEL.'.c~g" '.$TEMP_P.' >> '.$OUTFILE; 53 | system($command); 54 | 55 | unlink $TEMP_P; 56 | unlink $TEMP_B; 57 | unlink $TEMP_T; 58 | 59 | sub writeToFile() { 60 | my $file = $_[0]; 61 | my $content = $_[1]; 62 | 63 | open FILE, ">$file" or die "Error writing to $file"; 64 | 65 | print FILE $content; 66 | 67 | close FILE; 68 | } 69 | -------------------------------------------------------------------------------- /test_c/bicg/bicg.h: -------------------------------------------------------------------------------- 1 | /** 2 | * This version is stamped on May 10, 2016 3 | * 4 | * Contact: 5 | * Louis-Noel Pouchet 6 | * Tomofumi Yuki 7 | * 8 | * Web address: http://polybench.sourceforge.net 9 | */ 10 | #ifndef _BICG_H 11 | # define _BICG_H 12 | 13 | /* Default to LARGE_DATASET. */ 14 | # if !defined(MINI_DATASET) && !defined(SMALL_DATASET) && !defined(MEDIUM_DATASET) && !defined(LARGE_DATASET) && !defined(EXTRALARGE_DATASET) 15 | # define MINI_DATASET 16 | # endif 17 | 18 | # if !defined(M) && !defined(N) 19 | /* Define sample dataset sizes. */ 20 | # ifdef MINI_DATASET 21 | # define M 32//38 22 | # define N 32//42 23 | # endif 24 | 25 | # ifdef SMALL_DATASET 26 | # define M 116 27 | # define N 124 28 | # endif 29 | 30 | # ifdef MEDIUM_DATASET 31 | # define M 390 32 | # define N 410 33 | # endif 34 | 35 | # ifdef LARGE_DATASET 36 | # define M 1900 37 | # define N 2100 38 | # endif 39 | 40 | # ifdef EXTRALARGE_DATASET 41 | # define M 1800 42 | # define N 2200 43 | # endif 44 | 45 | 46 | #endif /* !(M N) */ 47 | 48 | # define _PB_M POLYBENCH_LOOP_BOUND(M,m) 49 | # define _PB_N POLYBENCH_LOOP_BOUND(N,n) 50 | 51 | 52 | /* Default data type */ 53 | # if !defined(DATA_TYPE_IS_INT) && !defined(DATA_TYPE_IS_FLOAT) && !defined(DATA_TYPE_IS_DOUBLE) 54 | # define DATA_TYPE_IS_INT 55 | # endif 56 | 57 | #ifdef DATA_TYPE_IS_INT 58 | # define DATA_TYPE int 59 | # define DATA_PRINTF_MODIFIER "%d " 60 | #endif 61 | 62 | #ifdef DATA_TYPE_IS_FLOAT 63 | # define DATA_TYPE float 64 | # define DATA_PRINTF_MODIFIER "%0.2f " 65 | # define SCALAR_VAL(x) x##f 66 | # define SQRT_FUN(x) sqrtf(x) 67 | # define EXP_FUN(x) expf(x) 68 | # define POW_FUN(x,y) powf(x,y) 69 | # endif 70 | 71 | #ifdef DATA_TYPE_IS_DOUBLE 72 | # define DATA_TYPE double 73 | # define DATA_PRINTF_MODIFIER "%0.2lf " 74 | # define SCALAR_VAL(x) x 75 | # define SQRT_FUN(x) sqrt(x) 76 | # define EXP_FUN(x) exp(x) 77 | # define POW_FUN(x,y) pow(x,y) 78 | # endif 79 | 80 | #endif /* !_BICG_H */ 81 | -------------------------------------------------------------------------------- /src/LoopInterface.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "LoopInterface.h" 15 | #include "ArrayName.h" 16 | 17 | 18 | void get_loop_input(Loop *L, std::vector &loop_read) 19 | { 20 | for(Loop::block_iterator BI=L->block_begin(), BE=L->block_end(); BI !=BE; ++BI) 21 | { 22 | BasicBlock *bb=*BI; 23 | for(auto iti=bb->begin();iti!=bb->end();++iti) 24 | { 25 | if(isa(iti)){ 26 | Value *array=get_array_name(iti); 27 | std::vector::iterator i; 28 | if(loop_read.empty()){ 29 | loop_read.push_back(array); 30 | } 31 | else{ 32 | for(i=loop_read.begin();i!=loop_read.end();++i) 33 | { 34 | Value *array1=*i; 35 | if(array1==array){ 36 | break; 37 | } 38 | } 39 | 40 | if(i==loop_read.end()){ 41 | i--; 42 | Value *array2=*i; 43 | if(array != array2){ 44 | loop_read.push_back(array); 45 | } 46 | } 47 | } 48 | } 49 | } 50 | } 51 | } 52 | 53 | void get_loop_output(Loop *L, std::vector &loop_write) 54 | { 55 | for(Loop::block_iterator BI=L->block_begin(), BE=L->block_end(); BI !=BE; ++BI) 56 | { 57 | BasicBlock *bb=*BI; 58 | for(auto iti=bb->begin();iti!=bb->end();++iti) 59 | { 60 | if(isa(iti)){ 61 | Value *array=get_array_name(iti); 62 | std::vector::iterator i; 63 | if(loop_write.empty()){ 64 | loop_write.push_back(array); 65 | } 66 | else{ 67 | for(i=loop_write.begin();i!=loop_write.end();++i) 68 | { 69 | Value *array1=*i; 70 | if(array1==array){ 71 | break; 72 | } 73 | } 74 | if(i==loop_write.end()){ 75 | i--; 76 | Value *array2=*i; 77 | if(array != array2){ 78 | loop_write.push_back(array); 79 | } 80 | } 81 | } 82 | } 83 | } 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /test_c/utilities/makefile-gen.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | # Generates Makefile for each benchmark in polybench 4 | # Expects to be executed from root folder of polybench 5 | # 6 | # Written by Tomofumi Yuki, 11/21 2014 7 | # 8 | 9 | my $GEN_CONFIG = 0; 10 | my $TARGET_DIR = "."; 11 | 12 | if ($#ARGV !=0 && $#ARGV != 1) { 13 | printf("usage perl makefile-gen.pl output-dir [-cfg]\n"); 14 | printf(" -cfg option generates config.mk in the output-dir.\n"); 15 | exit(1); 16 | } 17 | 18 | 19 | 20 | foreach my $arg (@ARGV) { 21 | if ($arg =~ /-cfg/) { 22 | $GEN_CONFIG = 1; 23 | } elsif (!($arg =~ /^-/)) { 24 | $TARGET_DIR = $arg; 25 | } 26 | } 27 | 28 | 29 | my %categories = ( 30 | 'linear-algebra/blas' => 3, 31 | 'linear-algebra/kernels' => 3, 32 | 'linear-algebra/solvers' => 3, 33 | 'datamining' => 2, 34 | 'stencils' => 2, 35 | 'medley' => 2 36 | ); 37 | 38 | my %extra_flags = ( 39 | 'cholesky' => '-lm', 40 | 'gramschmidt' => '-lm', 41 | 'correlation' => '-lm' 42 | ); 43 | 44 | foreach $key (keys %categories) { 45 | my $target = $TARGET_DIR.'/'.$key; 46 | opendir DIR, $target or die "directory $target not found.\n"; 47 | while (my $dir = readdir DIR) { 48 | next if ($dir=~'^\..*'); 49 | next if (!(-d $target.'/'.$dir)); 50 | 51 | my $kernel = $dir; 52 | my $file = $target.'/'.$dir.'/Makefile'; 53 | my $polybenchRoot = '../'x$categories{$key}; 54 | my $configFile = $polybenchRoot.'config.mk'; 55 | my $utilityDir = $polybenchRoot.'utilities'; 56 | 57 | open FILE, ">$file" or die "failed to open $file."; 58 | 59 | print FILE << "EOF"; 60 | include $configFile 61 | 62 | EXTRA_FLAGS=$extra_flags{$kernel} 63 | 64 | $kernel: $kernel.c $kernel.h 65 | \${VERBOSE} \${CC} -o $kernel $kernel.c \${CFLAGS} -I. -I$utilityDir $utilityDir/polybench.c \${EXTRA_FLAGS} 66 | 67 | clean: 68 | @ rm -f $kernel 69 | 70 | EOF 71 | 72 | close FILE; 73 | } 74 | 75 | 76 | closedir DIR; 77 | } 78 | 79 | if ($GEN_CONFIG) { 80 | open FILE, '>'.$TARGET_DIR.'/config.mk'; 81 | 82 | print FILE << "EOF"; 83 | CC=gcc 84 | CFLAGS=-O2 -DPOLYBENCH_DUMP_ARRAYS -DPOLYBENCH_USE_C99_PROTO 85 | EOF 86 | 87 | close FILE; 88 | 89 | } 90 | 91 | -------------------------------------------------------------------------------- /test_c/gemm/gemm.h: -------------------------------------------------------------------------------- 1 | /** 2 | * This version is stamped on May 10, 2016 3 | * 4 | * Contact: 5 | * Louis-Noel Pouchet 6 | * Tomofumi Yuki 7 | * 8 | * Web address: http://polybench.sourceforge.net 9 | */ 10 | #ifndef _GEMM_H 11 | # define _GEMM_H 12 | 13 | /* Default to LARGE_DATASET. */ 14 | # if !defined(MINI_DATASET) && !defined(SMALL_DATASET) && !defined(MEDIUM_DATASET) && !defined(LARGE_DATASET) && !defined(EXTRALARGE_DATASET) 15 | # define MINI_DATASET 16 | # endif 17 | 18 | # if !defined(NI) && !defined(NJ) && !defined(NK) 19 | /* Define sample dataset sizes. */ 20 | # ifdef MINI_DATASET 21 | # define NI 16//20 22 | # define NJ 16//25 23 | # define NK 16//30 24 | # endif 25 | 26 | # ifdef SMALL_DATASET 27 | # define NI 60 28 | # define NJ 70 29 | # define NK 80 30 | # endif 31 | 32 | # ifdef MEDIUM_DATASET 33 | # define NI 200 34 | # define NJ 220 35 | # define NK 240 36 | # endif 37 | 38 | # ifdef LARGE_DATASET 39 | # define NI 1000 40 | # define NJ 1100 41 | # define NK 1200 42 | # endif 43 | 44 | # ifdef EXTRALARGE_DATASET 45 | # define NI 2000 46 | # define NJ 2300 47 | # define NK 2600 48 | # endif 49 | 50 | 51 | #endif /* !(NI NJ NK) */ 52 | 53 | # define _PB_NI POLYBENCH_LOOP_BOUND(NI,ni) 54 | # define _PB_NJ POLYBENCH_LOOP_BOUND(NJ,nj) 55 | # define _PB_NK POLYBENCH_LOOP_BOUND(NK,nk) 56 | 57 | 58 | /* Default data type */ 59 | # if !defined(DATA_TYPE_IS_INT) && !defined(DATA_TYPE_IS_FLOAT) && !defined(DATA_TYPE_IS_DOUBLE) 60 | # define DATA_TYPE_IS_INT 61 | # endif 62 | 63 | #ifdef DATA_TYPE_IS_INT 64 | # define DATA_TYPE int 65 | # define DATA_PRINTF_MODIFIER "%d " 66 | #endif 67 | 68 | #ifdef DATA_TYPE_IS_FLOAT 69 | # define DATA_TYPE float 70 | # define DATA_PRINTF_MODIFIER "%0.2f " 71 | # define SCALAR_VAL(x) x##f 72 | # define SQRT_FUN(x) sqrtf(x) 73 | # define EXP_FUN(x) expf(x) 74 | # define POW_FUN(x,y) powf(x,y) 75 | # endif 76 | 77 | #ifdef DATA_TYPE_IS_DOUBLE 78 | # define DATA_TYPE double 79 | # define DATA_PRINTF_MODIFIER "%0.2lf " 80 | # define SCALAR_VAL(x) x 81 | # define SQRT_FUN(x) sqrt(x) 82 | # define EXP_FUN(x) exp(x) 83 | # define POW_FUN(x,y) pow(x,y) 84 | # endif 85 | 86 | #endif /* !_GEMM_H */ 87 | -------------------------------------------------------------------------------- /src/ArrayName.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "ArrayName.h" 15 | 16 | 17 | Value *check_PHI_operand(PHINode *phi) 18 | { 19 | Value *val=NULL; 20 | Value *val_tmp=NULL; 21 | for(unsigned i=0, e=phi->getNumIncomingValues();i!=e;i++) 22 | { 23 | Value *incoming=phi->getIncomingValue(i); 24 | if( (!(isa(incoming))) && (!(isa(incoming))) ) 25 | { 26 | val=incoming; 27 | return val; //consider most cases to break and continue 28 | } 29 | else if(GetElementPtrInst *GEP_incoming=dyn_cast(incoming)) 30 | { 31 | val_tmp=GEP_incoming->getPointerOperand(); 32 | if(isa(val_tmp)) 33 | { 34 | if(val_tmp==phi){ 35 | val=val_tmp; 36 | //return val; 37 | } 38 | else{ 39 | val=0; 40 | } 41 | } 42 | else{ 43 | val=val_tmp; 44 | return val; 45 | } 46 | } 47 | else if(isa(incoming)) 48 | { 49 | val=0; 50 | continue; 51 | } 52 | } 53 | return val; 54 | } 55 | 56 | 57 | Value *get_array_name(Instruction *inst) 58 | { 59 | Value *array_name=NULL; 60 | Value *op=NULL; 61 | 62 | if(LoadInst *load_inst=dyn_cast(inst)){ 63 | op=load_inst->getPointerOperand(); 64 | } 65 | else if(StoreInst *store_inst=dyn_cast(inst)){ 66 | op=store_inst->getPointerOperand(); 67 | } 68 | //else errs()<<"This instruction is neither a load nor a store.\n"; 69 | 70 | if(GetElementPtrInst *OP_GEP=dyn_cast(op)){ 71 | array_name=OP_GEP->getPointerOperand(); 72 | } 73 | else if(PHINode *OP_PHI=dyn_cast(op)){ 74 | array_name=check_PHI_operand(OP_PHI); 75 | } 76 | else if(Instruction *OP_Inst=dyn_cast(op)){ 77 | for(unsigned i=0; i!=OP_Inst->getNumOperands(); ++i){ 78 | Value *OP = OP_Inst->getOperand(i); 79 | if(GetElementPtrInst *tmp_inst = dyn_cast(OP)){ 80 | array_name=tmp_inst->getPointerOperand(); 81 | break; 82 | } 83 | else{ 84 | array_name=OP;//Modified 85 | } 86 | } 87 | } 88 | else{ 89 | array_name=op; 90 | } 91 | return array_name; 92 | } 93 | -------------------------------------------------------------------------------- /test_c/utilities/polybench.spec: -------------------------------------------------------------------------------- 1 | kernel category datatype params MINI SMALL MEDIUM LARGE EXTRALARGE 2 | correlation datamining double M N 28 32 80 100 240 260 1200 1400 2600 3000 3 | covariance datamining double M N 28 32 80 100 240 260 1200 1400 2600 3000 4 | 2mm linear-algebra/kernels double NI NJ NK NL 16 18 22 24 40 50 70 80 180 190 210 220 800 900 1100 1200 1600 1800 2200 2400 5 | 3mm linear-algebra/kernels double NI NJ NK NL NM 16 18 20 22 24 40 50 60 70 80 180 190 200 210 220 800 900 1000 1100 1200 1600 1800 2000 2200 2400 6 | atax linear-algebra/kernels double M N 38 42 116 124 390 410 1900 2100 1800 2200 7 | bicg linear-algebra/kernels double M N 38 42 116 124 390 410 1900 2100 1800 2200 8 | doitgen linear-algebra/kernels double NQ NR NP 8 10 12 20 25 30 40 50 60 140 150 160 220 250 270 9 | mvt linear-algebra/kernels double N 40 120 400 2000 4000 10 | gemm linear-algebra/blas double NI NJ NK 20 25 30 60 70 80 200 220 240 1000 1100 1200 2000 2300 2600 11 | gemver linear-algebra/blas double N 40 120 400 2000 4000 12 | gesummv linear-algebra/blas double N 30 90 250 1300 2800 13 | symm linear-algebra/blas double M N 20 30 60 80 200 240 1000 1200 2000 2600 14 | syr2k linear-algebra/blas double M N 20 30 60 80 200 240 1000 1200 2000 2600 15 | syrk linear-algebra/blas double M N 20 30 60 80 200 240 1000 1200 2000 2600 16 | trmm linear-algebra/blas double M N 20 30 60 80 200 240 1000 1200 2000 2600 17 | cholesky linear-algebra/solvers double N 40 120 400 2000 4000 18 | durbin linear-algebra/solvers double N 40 120 400 2000 4000 19 | gramschmidt linear-algebra/solvers double M N 20 30 60 80 200 240 1000 1200 2000 2600 20 | lu linear-algebra/solvers double N 40 120 400 2000 4000 21 | ludcmp linear-algebra/solvers double N 40 120 400 2000 4000 22 | trisolv linear-algebra/solvers double N 40 120 400 2000 4000 23 | deriche medley float W H 64 64 192 128 720 480 4096 2160 7680 4320 24 | floyd-warshall medley int N 60 180 500 2800 5600 25 | nussinov medley int N 60 180 500 2500 5500 26 | adi stencils double TSTEPS N 20 20 40 60 100 200 500 1000 1000 2000 27 | fdtd-2d stencils double TMAX NX NY 20 20 30 40 60 80 100 200 240 500 1000 1200 1000 2000 2600 28 | heat-3d stencils double TSTEPS N 20 10 40 20 100 40 500 120 1000 200 29 | jacobi-1d stencils double TSTEPS N 20 30 40 120 100 400 500 2000 1000 4000 30 | jacobi-2d stencils double TSTEPS N 20 30 40 90 100 250 500 1300 1000 2800 31 | seidel-2d stencils double TSTEPS N 20 40 40 120 100 400 500 2000 1000 4000 -------------------------------------------------------------------------------- /src/ComputeMemLatency.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef COMPUTEMEMLATENCY_H_ 15 | #define COMPUTEMEMLATENCY_H_ 16 | 17 | #include "test.h" 18 | 19 | int partition_load_num(LoopInfo *LI, BasicBlock *bb, Instruction *inst, std::map &instr_index_loop, std::map &load_order_buff); 20 | int partition_store_num(LoopInfo* LI, BasicBlock *bb, Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 21 | int compute_asap_load_num(BasicBlock *bb, Instruction *inst, std::map &instr_index_loop, std::map &load_order_buff); 22 | int compute_asap_store_num(LoopInfo* LI, BasicBlock *bb, Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 23 | float mux_latency(LoopInfo* LI, BasicBlock *bb, Instruction *inst); 24 | float get_load_latency(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::map &load_order_buff); 25 | bool load_before_store_partitioned(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 26 | float get_store_latency(LoopInfo* LI, Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop); 27 | PHINode *get_previous_phi(Instruction *inst); 28 | bool loop_unroll_effective(Loop *L); 29 | bool loop_carry_load_store_dependency(LoopInfo *LI, Instruction *load, Instruction *store); 30 | void reset_sameArray_store_latency(LoopInfo *LI, BasicBlock *bb, Instruction *inst, int unroll_factor, std::map &instr_index_loop, std::vector > *dependence_loop); 31 | void update_after_store(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 32 | void update_after_load(Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop); 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /test_c/gemm/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | /* Include polybench common header. */ 7 | #include "../utilities/polybench.h" 8 | 9 | /* Include benchmark-specific header. */ 10 | #include "gemm.h" 11 | /* Array initialization. */ 12 | void init_array(int ni, int nj, int nk, int C[NI][NJ],int A[NI][NK],int B[NK][NJ]) 13 | { 14 | int i, j; 15 | for (i = 0; i < ni; i++) 16 | for (j = 0; j < nj; j++) 17 | C[i][j] = (int) ((i*j+1) % ni) / ni; 18 | for (i = 0; i < ni; i++) 19 | for (j = 0; j < nk; j++) 20 | A[i][j] = (int) (i*(j+1) % nk) / nk; 21 | for (i = 0; i < nk; i++) 22 | for (j = 0; j < nj; j++) 23 | B[i][j] = (int) (i*(j+2) % nj) / nj; 24 | } 25 | 26 | 27 | /* DCE code. Must scan the entire live-out data. 28 | Can be used also to check the correctness of the output. */ 29 | void print_array(int ni, int nj, int C[NI][NJ]) 30 | { 31 | int i, j; 32 | 33 | POLYBENCH_DUMP_START; 34 | POLYBENCH_DUMP_BEGIN("C"); 35 | for (i = 0; i < ni; i++) 36 | for (j = 0; j < nj; j++) { 37 | if ((i * ni + j) % 20 == 0) fprintf (POLYBENCH_DUMP_TARGET, "\n"); 38 | fprintf (POLYBENCH_DUMP_TARGET, DATA_PRINTF_MODIFIER, C[i][j]); 39 | } 40 | POLYBENCH_DUMP_END("C"); 41 | POLYBENCH_DUMP_FINISH; 42 | } 43 | 44 | 45 | int main(int argc, char** argv) 46 | { 47 | /* Retrieve problem size. */ 48 | int ni = NI; 49 | int nj = NJ; 50 | int nk = NK; 51 | 52 | /* Variable declaration/allocation. */ 53 | POLYBENCH_2D_ARRAY_DECL(C,int,NI,NJ,ni,nj); 54 | POLYBENCH_2D_ARRAY_DECL(A,int,NI,NK,ni,nk); 55 | POLYBENCH_2D_ARRAY_DECL(B,int,NK,NJ,nk,nj); 56 | 57 | /* Initialize array(s). */ 58 | init_array (ni, nj, nk, 59 | POLYBENCH_ARRAY(C), 60 | POLYBENCH_ARRAY(A), 61 | POLYBENCH_ARRAY(B)); 62 | 63 | /* Start timer. */ 64 | polybench_start_instruments; 65 | 66 | /* Run kernel. */ 67 | kernel_gemm (POLYBENCH_ARRAY(C), 68 | POLYBENCH_ARRAY(A), 69 | POLYBENCH_ARRAY(B)); 70 | 71 | /* Stop and print timer. */ 72 | polybench_stop_instruments; 73 | polybench_print_instruments; 74 | 75 | /* Prevent dead-code elimination. All live-out data must be printed 76 | by the function call in argument. */ 77 | polybench_prevent_dce(print_array(ni, nj, POLYBENCH_ARRAY(C))); 78 | 79 | /* Be clean. */ 80 | POLYBENCH_FREE_ARRAY(C); 81 | POLYBENCH_FREE_ARRAY(A); 82 | POLYBENCH_FREE_ARRAY(B); 83 | 84 | return 0; 85 | } 86 | -------------------------------------------------------------------------------- /test_c/utilities/template-for-new-benchmark.c: -------------------------------------------------------------------------------- 1 | /** 2 | * This version is stamped on May 10, 2016 3 | * 4 | * Contact: 5 | * Louis-Noel Pouchet 6 | * Tomofumi Yuki 7 | * 8 | * Web address: http://polybench.sourceforge.net 9 | */ 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | /* Include polybench common header. */ 16 | #include "../utilities/polybench.h" 17 | 18 | /* Include benchmark-specific header. */ 19 | /* Default data type is double, default size is N=1024. */ 20 | #include "template-for-new-benchmark.h" 21 | 22 | 23 | /* Array initialization. */ 24 | static 25 | void init_array(int n, DATA_TYPE POLYBENCH_2D(C,N,N,n,n)) 26 | { 27 | int i, j; 28 | 29 | for (i = 0; i < n; i++) 30 | for (j = 0; j < n; j++) 31 | C[i][j] = 42; 32 | } 33 | 34 | 35 | /* DCE code. Must scan the entire live-out data. 36 | Can be used also to check the correctness of the output. */ 37 | static 38 | void print_array(int n, DATA_TYPE POLYBENCH_2D(C,N,N,n,n)) 39 | { 40 | int i, j; 41 | 42 | for (i = 0; i < n; i++) 43 | for (j = 0; j < n; j++) { 44 | fprintf (stderr, DATA_PRINTF_MODIFIER, C[i][j]); 45 | if (i % 20 == 0) fprintf (stderr, "\n"); 46 | } 47 | fprintf (stderr, "\n"); 48 | } 49 | 50 | 51 | /* Main computational kernel. The whole function will be timed, 52 | including the call and return. */ 53 | static 54 | void kernel_template(int n, DATA_TYPE POLYBENCH_2D(C,N,N,n,n)) 55 | { 56 | int i, j; 57 | 58 | #pragma scop 59 | for (i = 0; i < _PB_N; i++) 60 | for (j = 0; j < _PB_N; j++) 61 | C[i][j] += 42; 62 | #pragma endscop 63 | 64 | } 65 | 66 | 67 | int main(int argc, char** argv) 68 | { 69 | /* Retrieve problem size. */ 70 | int n = N; 71 | 72 | /* Variable declaration/allocation. */ 73 | POLYBENCH_2D_ARRAY_DECL(C,DATA_TYPE,N,N,n,n); 74 | 75 | /* Initialize array(s). */ 76 | init_array (n, POLYBENCH_ARRAY(C)); 77 | 78 | /* Start timer. */ 79 | polybench_start_instruments; 80 | 81 | /* Run kernel. */ 82 | kernel_template (n, POLYBENCH_ARRAY(C)); 83 | 84 | /* Stop and print timer. */ 85 | polybench_stop_instruments; 86 | polybench_print_instruments; 87 | 88 | /* Prevent dead-code elimination. All live-out data must be printed 89 | by the function call in argument. */ 90 | polybench_prevent_dce(print_array(n, POLYBENCH_ARRAY(C))); 91 | 92 | /* Be clean. */ 93 | POLYBENCH_FREE_ARRAY(C); 94 | 95 | return 0; 96 | } 97 | -------------------------------------------------------------------------------- /src/ComputeCriticalPath.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef COMPUTECRITICALPATH_H_ 15 | #define COMPUTECRITICALPATH_H_ 16 | 17 | #include "test.h" 18 | 19 | void loop_compute_critical_path_gep(Instruction *inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop, std::map > &inst_map_branch); 20 | void loop_compute_critical_path(Instruction * inst, float latency, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop, std::map > &inst_map_branch); 21 | void loop_compute_critical_path_call(Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop, std::map > &inst_map_branch); 22 | void loop_compute_critical_path_branch(LoopInfo* LI, Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop, std::map > &inst_map_branch); 23 | void loop_compute_critical_path_switch(LoopInfo* LI, Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::vector > *dependence_loop, std::map > &inst_map_branch); 24 | void update(LoopInfo* LI, Instruction *inst, unsigned &index_loop, std::map &instr_index_loop, std::map &load_order_buff, std::vector > *dependence_loop, std::map > &inst_map_branch); 25 | float loop_solveCP(std::vector > *dependence, std::map &loop_inst_till_latency); 26 | void dependence_set(LoopInfo* LI, Loop *L, std::map &instr_index_loop, std::map &load_order_buff, std::vector > *dependence_loop, std::map > &inst_map_branch); 27 | float loopCP(LoopInfo* LI, Loop* L, std::map &load_order_buff); 28 | float dependent_loopCP(LoopInfo* LI, Loop *L, std::map &load_order_buff); 29 | float update_loopCP(LoopInfo* LI, Loop *L, std::map &load_order_buff); 30 | 31 | 32 | #endif 33 | -------------------------------------------------------------------------------- /src/Reschedule.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #ifndef RESCHEDULE_H_ 15 | #define RESCHEDULE_H_ 16 | 17 | #include "test.h" 18 | 19 | void reschedule_dependence(LoopInfo* LI, int freq, std::map &instr_index_loop,std::vector > *dependence_loop); 20 | void reschedule_dependence_100(Instruction *inst, std::map::iterator it, std::vector >::iterator i, std::map &instr_index_loop, std::vector > *dependence_loop); 21 | void reschedule_dependence_125(Instruction *inst, std::map::iterator it, std::vector >::iterator i, std::map &instr_index_loop, std::vector > *dependence_loop); 22 | void reschedule_dependence_150(Instruction *inst, std::map::iterator it, std::vector >::iterator i, std::map &instr_index_loop, std::vector > *dependence_loop); 23 | void reschedule_dependence_200(Instruction *inst, std::map::iterator it, std::vector >::iterator i, std::map &instr_index_loop, std::vector > *dependence_loop); 24 | void reschedule_dependence_250(Instruction *inst, std::map::iterator it, std::vector >::iterator i, std::map &instr_index_loop, std::vector > *dependence_loop); 25 | bool num_is_int(float number); 26 | bool latency_is_large(Instruction *inst,std::map &instr_index_loop,std::vector > *dependence_loop); 27 | bool latency_is_large125(Instruction *inst,std::map &instr_index_loop,std::vector > *dependence_loop); 28 | void reschedule_load_freq125(bool large_latency_flag,Instruction *inst,Instruction *inst1,std::map &instr_index_loop,std::vector > *dependence_loop); 29 | bool load_shift_store(Instruction*inst,std::map &instr_index_loop,std::vector > *dependence_loop); 30 | bool before_inst_large(Instruction *inst,std::map &instr_index_loop,std::vector > *dependence_loop); 31 | bool after_inst_large(Instruction *inst,std::map &instr_index_loop,std::vector > *dependence_loop); 32 | 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /test/bicg.ll: -------------------------------------------------------------------------------- 1 | ; ModuleID = 'bicg.c' 2 | target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" 3 | target triple = "x86_64-unknown-linux-gnu" 4 | 5 | ; Function Attrs: nounwind uwtable 6 | define void @kernel_bicg([38 x i32]* nocapture readonly %A, i32* nocapture %s, i32* nocapture %q, i32* nocapture readonly %p, i32* nocapture readonly %r) #0 { 7 | entry: 8 | br label %for.body 9 | 10 | for.body: ; preds = %for.inc26, %entry 11 | %indvars.iv48 = phi i64 [ 0, %entry ], [ %indvars.iv.next49, %for.inc26 ] 12 | %arrayidx = getelementptr inbounds i32* %q, i64 %indvars.iv48 13 | store i32 0, i32* %arrayidx, align 4, !tbaa !1 14 | %arrayidx7 = getelementptr inbounds i32* %r, i64 %indvars.iv48 15 | br label %for.body3 16 | 17 | for.body3: ; preds = %for.body3, %for.body 18 | %indvars.iv = phi i64 [ 0, %for.body ], [ %indvars.iv.next, %for.body3 ] 19 | %arrayidx5 = getelementptr inbounds i32* %s, i64 %indvars.iv 20 | %0 = load i32* %arrayidx5, align 4, !tbaa !1 21 | %1 = load i32* %arrayidx7, align 4, !tbaa !1 22 | %arrayidx11 = getelementptr inbounds [38 x i32]* %A, i64 %indvars.iv48, i64 %indvars.iv 23 | %2 = load i32* %arrayidx11, align 4, !tbaa !1 24 | %mul = mul nsw i32 %2, %1 25 | %add = add nsw i32 %mul, %0 26 | store i32 %add, i32* %arrayidx5, align 4, !tbaa !1 27 | %3 = load i32* %arrayidx, align 4, !tbaa !1 28 | %4 = load i32* %arrayidx11, align 4, !tbaa !1 29 | %arrayidx21 = getelementptr inbounds i32* %p, i64 %indvars.iv 30 | %5 = load i32* %arrayidx21, align 4, !tbaa !1 31 | %mul22 = mul nsw i32 %5, %4 32 | %add23 = add nsw i32 %mul22, %3 33 | store i32 %add23, i32* %arrayidx, align 4, !tbaa !1 34 | %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 35 | %exitcond = icmp eq i64 %indvars.iv.next, 38 36 | br i1 %exitcond, label %for.inc26, label %for.body3 37 | 38 | for.inc26: ; preds = %for.body3 39 | %indvars.iv.next49 = add nuw nsw i64 %indvars.iv48, 1 40 | %exitcond50 = icmp eq i64 %indvars.iv.next49, 42 41 | br i1 %exitcond50, label %for.end28, label %for.body 42 | 43 | for.end28: ; preds = %for.inc26 44 | ret void 45 | } 46 | 47 | 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" } 48 | 49 | !llvm.ident = !{!0} 50 | 51 | !0 = metadata !{metadata !"clang version 3.4 (tags/RELEASE_34/final)"} 52 | !1 = metadata !{metadata !2, metadata !2, i64 0} 53 | !2 = metadata !{metadata !"int", metadata !3, i64 0} 54 | !3 = metadata !{metadata !"omnipotent char", metadata !4, i64 0} 55 | !4 = metadata !{metadata !"Simple C/C++ TBAA"} 56 | -------------------------------------------------------------------------------- /test_c/bicg/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | /* Include polybench common header. */ 7 | #include "../utilities/polybench.h" 8 | 9 | /* Include benchmark-specific header. */ 10 | #include "bicg.h" 11 | 12 | 13 | /* Array initialization. */ 14 | static 15 | void init_array (int m, int n, 16 | DATA_TYPE POLYBENCH_2D(A,N,M,n,m), 17 | DATA_TYPE POLYBENCH_1D(r,N,n), 18 | DATA_TYPE POLYBENCH_1D(p,M,m)) 19 | { 20 | int i, j; 21 | 22 | for (i = 0; i < m; i++) 23 | p[i] = (DATA_TYPE)(i % m) / m; 24 | for (i = 0; i < n; i++) { 25 | r[i] = (DATA_TYPE)(i % n) / n; 26 | for (j = 0; j < m; j++) 27 | A[i][j] = (DATA_TYPE) (i*(j+1) % n)/n; 28 | } 29 | } 30 | 31 | 32 | /* DCE code. Must scan the entire live-out data. 33 | Can be used also to check the correctness of the output. */ 34 | static 35 | void print_array(int m, int n, 36 | DATA_TYPE POLYBENCH_1D(s,M,m), 37 | DATA_TYPE POLYBENCH_1D(q,N,n)) 38 | 39 | { 40 | int i; 41 | 42 | POLYBENCH_DUMP_START; 43 | POLYBENCH_DUMP_BEGIN("s"); 44 | for (i = 0; i < m; i++) { 45 | if (i % 20 == 0) fprintf (POLYBENCH_DUMP_TARGET, "\n"); 46 | fprintf (POLYBENCH_DUMP_TARGET, DATA_PRINTF_MODIFIER, s[i]); 47 | } 48 | POLYBENCH_DUMP_END("s"); 49 | POLYBENCH_DUMP_BEGIN("q"); 50 | for (i = 0; i < n; i++) { 51 | if (i % 20 == 0) fprintf (POLYBENCH_DUMP_TARGET, "\n"); 52 | fprintf (POLYBENCH_DUMP_TARGET, DATA_PRINTF_MODIFIER, q[i]); 53 | } 54 | POLYBENCH_DUMP_END("q"); 55 | POLYBENCH_DUMP_FINISH; 56 | } 57 | 58 | 59 | int main(int argc, char** argv) 60 | { 61 | /* Retrieve problem size. */ 62 | int n = N; 63 | int m = M; 64 | 65 | /* Variable declaration/allocation. */ 66 | POLYBENCH_2D_ARRAY_DECL(A, int, N, M, n, m); 67 | POLYBENCH_1D_ARRAY_DECL(s, int, M, m); 68 | POLYBENCH_1D_ARRAY_DECL(q, int, N, n); 69 | POLYBENCH_1D_ARRAY_DECL(p, int, M, m); 70 | POLYBENCH_1D_ARRAY_DECL(r, int, N, n); 71 | 72 | /* Initialize array(s). */ 73 | init_array (m, n, 74 | POLYBENCH_ARRAY(A), 75 | POLYBENCH_ARRAY(r), 76 | POLYBENCH_ARRAY(p)); 77 | 78 | /* Start timer. */ 79 | polybench_start_instruments; 80 | 81 | /* Run kernel. */ 82 | kernel_bicg ( 83 | POLYBENCH_ARRAY(A), 84 | POLYBENCH_ARRAY(s), 85 | POLYBENCH_ARRAY(q), 86 | POLYBENCH_ARRAY(p), 87 | POLYBENCH_ARRAY(r)); 88 | 89 | /* Stop and print timer. */ 90 | polybench_stop_instruments; 91 | polybench_print_instruments; 92 | 93 | /* Prevent dead-code elimination. All live-out data must be printed 94 | by the function call in argument. */ 95 | polybench_prevent_dce(print_array(m, n, POLYBENCH_ARRAY(s), POLYBENCH_ARRAY(q))); 96 | 97 | /* Be clean. */ 98 | POLYBENCH_FREE_ARRAY(A); 99 | POLYBENCH_FREE_ARRAY(s); 100 | POLYBENCH_FREE_ARRAY(q); 101 | POLYBENCH_FREE_ARRAY(p); 102 | POLYBENCH_FREE_ARRAY(r); 103 | 104 | return 0; 105 | } 106 | -------------------------------------------------------------------------------- /test_c/utilities/time_benchmark.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | ## time_benchmark.sh for in /Users/pouchet 3 | ## 4 | ## Made by Louis-Noel Pouchet 5 | ## Contact: 6 | ## 7 | ## Started on Sat Oct 29 00:03:48 2011 Louis-Noel Pouchet 8 | ## Last update Fri Apr 22 15:39:13 2016 Louis-Noel Pouchet 9 | ## 10 | 11 | ## Maximal variance accepted between the 3 median runs for performance results. 12 | ## Here 5% 13 | VARIANCE_ACCEPTED=5; 14 | 15 | if [ $# -ne 1 ]; then 16 | echo "Usage: ./time_benchmarh.sh "; 17 | echo "Example: ./time_benchmarh.sh \"./a.out\""; 18 | echo "Note: the file must be a Polybench program compiled with -DPOLYBENCH_TIME"; 19 | exit 1; 20 | fi; 21 | 22 | 23 | compute_mean_exec_time() 24 | { 25 | file="$1"; 26 | benchcomputed="$2"; 27 | cat "$file" | grep "[0-9]\+" | sort -n | head -n 4 | tail -n 3 > avg.out; 28 | expr="(0"; 29 | while read n; do 30 | expr="$expr+$n"; 31 | done < avg.out; 32 | time=`echo "scale=8;$expr)/3" | bc`; 33 | tmp=`echo "$time" | cut -d '.' -f 1`; 34 | if [ -z "$tmp" ]; then 35 | time="0$time"; 36 | fi; 37 | val1=`cat avg.out | head -n 1`; 38 | val2=`cat avg.out | head -n 2 | tail -n 1`; 39 | val3=`cat avg.out | head -n 3 | tail -n 1`; 40 | val11=`echo "a=$val1 - $time;if(0>a)a*=-1;a" | bc 2>&1`; 41 | test_err=`echo "$val11" | grep error`; 42 | if ! [ -z "$test_err" ]; then 43 | echo "[ERROR] Program output does not match expected single-line with time."; 44 | echo "[ERROR] The program must be a PolyBench, compiled with -DPOLYBENCH_TIME"; 45 | exit 1; 46 | fi; 47 | val12=`echo "a=$val2 - $time;if(0>a)a*=-1;a" | bc`; 48 | val13=`echo "a=$val3 - $time;if(0>a)a*=-1;a" | bc`; 49 | myvar=`echo "$val11 $val12 $val13" | awk '{ if ($1 > $2) { if ($1 > $3) print $1; else print $3; } else { if ($2 > $3) print $2; else print $3; } }'`; 50 | variance=`echo "scale=5;($myvar/$time)*100" | bc`; 51 | tmp=`echo "$variance" | cut -d '.' -f 1`; 52 | if [ -z "$tmp" ]; then 53 | variance="0$variance"; 54 | fi; 55 | compvar=`echo "$variance $VARIANCE_ACCEPTED" | awk '{ if ($1 < $2) print "ok"; else print "error"; }'`; 56 | if [ "$compvar" = "error" ]; then 57 | echo "[WARNING] Variance is above thresold, unsafe performance measurement"; 58 | echo " => max deviation=$variance%, tolerance=$VARIANCE_ACCEPTED%"; 59 | WARNING_VARIANCE="$WARNING_VARIANCE\n$benchcomputed: max deviation=$variance%, tolerance=$VARIANCE_ACCEPTED%"; 60 | else 61 | echo "[INFO] Maximal deviation from arithmetic mean of 3 average runs: $variance%"; 62 | fi; 63 | PROCESSED_TIME="$time"; 64 | rm -f avg.out; 65 | } 66 | 67 | echo "[INFO] Running 5 times $1..." 68 | echo "[INFO] Maximal variance authorized on 3 average runs: $VARIANCE_ACCEPTED%..."; 69 | 70 | $1 > ____tempfile.data.polybench; 71 | $1 >> ____tempfile.data.polybench; 72 | $1 >> ____tempfile.data.polybench; 73 | $1 >> ____tempfile.data.polybench; 74 | $1 >> ____tempfile.data.polybench; 75 | 76 | compute_mean_exec_time "____tempfile.data.polybench" "$1"; 77 | echo "[INFO] Normalized time: $PROCESSED_TIME"; 78 | rm -f ____tempfile.data.polybench; 79 | -------------------------------------------------------------------------------- /test/gemm.ll: -------------------------------------------------------------------------------- 1 | ; ModuleID = 'gemm.c' 2 | target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" 3 | target triple = "x86_64-unknown-linux-gnu" 4 | 5 | ; Function Attrs: nounwind uwtable 6 | define void @kernel_gemm([25 x i32]* nocapture %C, [30 x i32]* nocapture readonly %A, [25 x i32]* nocapture readonly %B) #0 { 7 | entry: 8 | br label %for.cond1.preheader 9 | 10 | for.cond1.preheader: ; preds = %for.inc32, %entry 11 | %indvars.iv60 = phi i64 [ 0, %entry ], [ %indvars.iv.next61, %for.inc32 ] 12 | br label %for.body3 13 | 14 | for.body3: ; preds = %for.body3, %for.cond1.preheader 15 | %indvars.iv = phi i64 [ 0, %for.cond1.preheader ], [ %indvars.iv.next, %for.body3 ] 16 | %arrayidx5 = getelementptr inbounds [25 x i32]* %C, i64 %indvars.iv60, i64 %indvars.iv 17 | %0 = load i32* %arrayidx5, align 4, !tbaa !1 18 | %mul = shl nsw i32 %0, 1 19 | store i32 %mul, i32* %arrayidx5, align 4, !tbaa !1 20 | %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1 21 | %exitcond = icmp eq i64 %indvars.iv.next, 25 22 | br i1 %exitcond, label %for.cond9.preheader, label %for.body3 23 | 24 | for.cond9.preheader: ; preds = %for.body3, %for.inc29 25 | %indvars.iv57 = phi i64 [ %indvars.iv.next58, %for.inc29 ], [ 0, %for.body3 ] 26 | %arrayidx15 = getelementptr inbounds [30 x i32]* %A, i64 %indvars.iv60, i64 %indvars.iv57 27 | br label %for.body11 28 | 29 | for.body11: ; preds = %for.body11, %for.cond9.preheader 30 | %indvars.iv54 = phi i64 [ 0, %for.cond9.preheader ], [ %indvars.iv.next55, %for.body11 ] 31 | %1 = load i32* %arrayidx15, align 4, !tbaa !1 32 | %mul16 = mul nsw i32 %1, 3 33 | %arrayidx20 = getelementptr inbounds [25 x i32]* %B, i64 %indvars.iv57, i64 %indvars.iv54 34 | %2 = load i32* %arrayidx20, align 4, !tbaa !1 35 | %mul21 = mul nsw i32 %mul16, %2 36 | %arrayidx25 = getelementptr inbounds [25 x i32]* %C, i64 %indvars.iv60, i64 %indvars.iv54 37 | %3 = load i32* %arrayidx25, align 4, !tbaa !1 38 | %add = add nsw i32 %3, %mul21 39 | store i32 %add, i32* %arrayidx25, align 4, !tbaa !1 40 | %indvars.iv.next55 = add nuw nsw i64 %indvars.iv54, 1 41 | %exitcond56 = icmp eq i64 %indvars.iv.next55, 25 42 | br i1 %exitcond56, label %for.inc29, label %for.body11 43 | 44 | for.inc29: ; preds = %for.body11 45 | %indvars.iv.next58 = add nuw nsw i64 %indvars.iv57, 1 46 | %exitcond59 = icmp eq i64 %indvars.iv.next58, 30 47 | br i1 %exitcond59, label %for.inc32, label %for.cond9.preheader 48 | 49 | for.inc32: ; preds = %for.inc29 50 | %indvars.iv.next61 = add nuw nsw i64 %indvars.iv60, 1 51 | %exitcond62 = icmp eq i64 %indvars.iv.next61, 20 52 | br i1 %exitcond62, label %for.end34, label %for.cond1.preheader 53 | 54 | for.end34: ; preds = %for.inc32 55 | ret void 56 | } 57 | 58 | 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" } 59 | 60 | !llvm.ident = !{!0} 61 | 62 | !0 = metadata !{metadata !"clang version 3.4 (tags/RELEASE_34/final)"} 63 | !1 = metadata !{metadata !2, metadata !2, i64 0} 64 | !2 = metadata !{metadata !"int", metadata !3, i64 0} 65 | !3 = metadata !{metadata !"omnipotent char", metadata !4, i64 0} 66 | !4 = metadata !{metadata !"Simple C/C++ TBAA"} 67 | -------------------------------------------------------------------------------- /test_c/utilities/header-gen.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | 3 | # Generates headers using specification in polybench.spec 4 | # 5 | # Written by Tomofumi Yuki, 11/21 2014 6 | # 7 | 8 | use File::Path; 9 | 10 | if ($#ARGV != 0) { 11 | printf("usage perl header-gen.pl output-dir\n"); 12 | exit(1); 13 | } 14 | 15 | my $SPECFILE = 'polybench.spec'; 16 | my $OUTDIR = $ARGV[0]; 17 | my @DATASET_NAMES = ('MINI', 'SMALL', 'MEDIUM', 'LARGE', 'EXTRALARGE'); 18 | 19 | if (!(-e $OUTDIR)) { 20 | mkdir $OUTDIR; 21 | } 22 | 23 | my %INPUT; 24 | my @keys; 25 | 26 | open FILE, $SPECFILE or die; 27 | while () { 28 | my $line = $_; 29 | $line =~ s/\r|\n//g; 30 | #lines tarting with # is treated as comments 31 | next if ($line=~/^\s*#/); 32 | next if ($line=~/^\s*[\r|\n]+$/); 33 | my @line = split(/\t+/, $line); 34 | 35 | if (!keys %INPUT ) { 36 | foreach (@line) { 37 | $INPUT{$_} = []; 38 | } 39 | @keys = @line; 40 | } else { 41 | for (my $i = 0; $i <= $#line; $i++) { 42 | push @{$INPUT{$keys[$i]}}, $line[$i] ; 43 | } 44 | } 45 | } 46 | 47 | close FILE; 48 | 49 | for (my $r = 0; $r <= $#{$INPUT{'kernel'}}; $r++) { 50 | &generateHeader($r); 51 | } 52 | 53 | sub generateHeader() { 54 | 55 | my $row = $_[0]; 56 | my $name = $INPUT{'kernel'}[$row]; 57 | my $category = $INPUT{'category'}[$row]; 58 | my $datatype = $INPUT{'datatype'}[$row]; 59 | my $datatypeUC = uc $datatype; 60 | my @params = split /\s+/, $INPUT{'params'}[$row]; 61 | 62 | 63 | my $headerDef = '_'. uc $name . '_H'; 64 | $headerDef =~ s/-/_/g; 65 | 66 | my $paramDefs; 67 | foreach $set (@DATASET_NAMES) { 68 | my @sizes = split /\s+/, $INPUT{$set}[$row]; 69 | $paramDefs .= '# ifdef '.$set."_DATASET\n"; 70 | for (my $i = 0; $i <= $#params; $i++) { 71 | $paramDefs .= '# define '.$params[$i].' '.$sizes[$i]."\n"; 72 | } 73 | $paramDefs .= '# endif '."\n\n"; 74 | } 75 | 76 | my $paramCheck = '# if'; 77 | my $loopBoundDef = ''; 78 | { 79 | my $first = 1; 80 | foreach (@params) { 81 | $paramCheck.= ' &&' if (!$first); 82 | $paramCheck .= " !defined($_)"; 83 | $first = 0; 84 | $loopBoundDef .= '# define _PB_'.$_.' POLYBENCH_LOOP_BOUND('.$_.','.lc $_.')'."\n"; 85 | } 86 | } 87 | 88 | my $kernelPath = "$OUTDIR/$category/$name"; 89 | if (!(-e $kernelPath)) { 90 | mkpath $kernelPath; 91 | } 92 | 93 | open HFILE, ">$kernelPath/$name.h"; 94 | print HFILE << "EOF"; 95 | #ifndef $headerDef 96 | # define $headerDef 97 | 98 | /* Default to LARGE_DATASET. */ 99 | # if !defined(MINI_DATASET) && !defined(SMALL_DATASET) && !defined(MEDIUM_DATASET) && !defined(LARGE_DATASET) && !defined(EXTRALARGE_DATASET) 100 | # define LARGE_DATASET 101 | # endif 102 | 103 | $paramCheck 104 | /* Define sample dataset sizes. */ 105 | $paramDefs 106 | #endif /* !(@params) */ 107 | 108 | $loopBoundDef 109 | 110 | /* Default data type */ 111 | # if !defined(DATA_TYPE_IS_INT) && !defined(DATA_TYPE_IS_FLOAT) && !defined(DATA_TYPE_IS_DOUBLE) 112 | # define DATA_TYPE_IS_$datatypeUC 113 | # endif 114 | 115 | #ifdef DATA_TYPE_IS_INT 116 | # define DATA_TYPE int 117 | # define DATA_PRINTF_MODIFIER "%d " 118 | #endif 119 | 120 | #ifdef DATA_TYPE_IS_FLOAT 121 | # define DATA_TYPE float 122 | # define DATA_PRINTF_MODIFIER "%0.2f " 123 | # define SCALAR_VAL(x) x##f 124 | # define SQRT_FUN(x) sqrtf(x) 125 | # define EXP_FUN(x) expf(x) 126 | # define POW_FUN(x,y) powf(x,y) 127 | # endif 128 | 129 | #ifdef DATA_TYPE_IS_DOUBLE 130 | # define DATA_TYPE double 131 | # define DATA_PRINTF_MODIFIER "%0.2lf " 132 | # define SCALAR_VAL(x) x 133 | # define SQRT_FUN(x) sqrt(x) 134 | # define EXP_FUN(x) exp(x) 135 | # define POW_FUN(x,y) pow(x,y) 136 | # endif 137 | 138 | #endif /* !$headerDef */ 139 | 140 | EOF 141 | close HFILE; 142 | } 143 | 144 | -------------------------------------------------------------------------------- /src/LoopUnrollFactor.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "LoopUnrollFactor.h" 15 | #include "GEP.h" 16 | 17 | 18 | int total_unroll_factor(Loop *L) 19 | { 20 | int factor=1; 21 | if(L!=NULL){ 22 | if(Loops_unroll[L]>=Loops_counter[L]){ 23 | Loop *parent=L->getParentLoop(); 24 | int parent_factor=total_unroll_factor(parent); 25 | factor=factor * Loops_unroll[L] *parent_factor; 26 | } 27 | else{ 28 | factor=factor * Loops_unroll[L]; 29 | } 30 | } 31 | return factor; 32 | } 33 | 34 | bool unroll_loop_relation(Loop *L1, Loop *L2) 35 | { 36 | bool unroll_related=false; 37 | if(L1==L2){ 38 | unroll_related=true; 39 | } 40 | else{ 41 | if(L2->contains(L1)){ 42 | if(Loops_unroll[L1]>=Loops_counter[L1]){ 43 | Loop *parent=L1->getParentLoop(); 44 | unroll_related=unroll_loop_relation(parent,L2); 45 | } 46 | } 47 | } 48 | return unroll_related; 49 | } 50 | 51 | int total_unroll_factor_ls(LoopInfo *LI, Loop *L, Instruction *inst) 52 | { 53 | int factor=1; 54 | int total_factor=total_unroll_factor(L); 55 | if(isa(inst)||isa(inst)){ 56 | GetElementPtrInst *gep=get_GEP(inst); 57 | if(gep!=NULL){ 58 | for(User::op_iterator II=gep->idx_begin(),IE=gep->idx_end(); II!=IE; ++II) 59 | { 60 | if(Instruction *tmp_inst=dyn_cast(*II)) 61 | { 62 | BasicBlock *bb=tmp_inst->getParent(); 63 | Loop *l=LI->getLoopFor(bb); 64 | if(l!=NULL){ 65 | bool related=unroll_loop_relation(L,l); 66 | if(related==true){ 67 | factor *= Loops_unroll[l]; 68 | } 69 | } 70 | } 71 | else{ 72 | BasicBlock *bb=gep->getParent(); 73 | Loop *l=LI->getLoopFor(bb); 74 | if(l!=NULL){ 75 | bool related=unroll_loop_relation(L,l); 76 | if(related==true){ 77 | factor *= Loops_unroll[l]; 78 | } 79 | } 80 | } 81 | } 82 | } 83 | else{ 84 | factor=total_factor; 85 | } 86 | } 87 | return factor; 88 | } 89 | 90 | 91 | int total_unroll_factor_op(LoopInfo *LI, Loop *L, Instruction *inst) 92 | { 93 | int factor=1; 94 | int total_factor=total_unroll_factor(L); 95 | bool op_is_ls=false; 96 | std::map loop_ul_counted; 97 | for(unsigned op=0; op!=inst->getNumOperands(); ++op) 98 | { 99 | Value *OP = inst->getOperand(op); 100 | if(Instruction *inst_op=dyn_cast(OP)){ 101 | if(isa(inst_op)||isa(inst_op)) 102 | { 103 | GetElementPtrInst *gep=get_GEP(inst_op); 104 | if(gep!=NULL) 105 | { 106 | for(User::op_iterator II=gep->idx_begin(),IE=gep->idx_end(); II!=IE; ++II) 107 | { 108 | if(Instruction *tmp_inst=dyn_cast(*II)) 109 | { 110 | BasicBlock *bb=tmp_inst->getParent(); 111 | Loop *l=LI->getLoopFor(bb); 112 | if(l!=NULL){ 113 | if(!loop_ul_counted.count(l)){ 114 | bool related=unroll_loop_relation(L,l); 115 | if(related==true){ 116 | factor *= Loops_unroll[l]; 117 | loop_ul_counted[l]=factor; 118 | op_is_ls=true; 119 | } 120 | } 121 | } 122 | } 123 | } 124 | } 125 | } 126 | else{ 127 | for(unsigned op1=0; op1!=inst_op->getNumOperands(); ++op1) 128 | { 129 | Value *OP1=inst_op->getOperand(op1); 130 | if(Instruction *inst_op1=dyn_cast(OP1)) 131 | { 132 | if(isa(inst_op1)||isa(inst_op1)) 133 | { 134 | GetElementPtrInst *gep=get_GEP(inst_op1); 135 | if(gep!=NULL){ 136 | for(User::op_iterator II=gep->idx_begin(),IE=gep->idx_end(); II!=IE; ++II){ 137 | if(Instruction *tmp_inst=dyn_cast(*II)){ 138 | BasicBlock *bb=tmp_inst->getParent(); 139 | Loop *l=LI->getLoopFor(bb); 140 | if(l!=NULL){ 141 | if(!loop_ul_counted.count(l)){ 142 | bool related=unroll_loop_relation(L,l); 143 | if(related==true){ 144 | factor *= Loops_unroll[l]; 145 | loop_ul_counted[l]=factor; 146 | op_is_ls=true; 147 | } 148 | } 149 | } 150 | } 151 | } 152 | } 153 | } 154 | } 155 | } 156 | } 157 | } 158 | } 159 | if(op_is_ls==false){ 160 | factor=total_factor; 161 | } 162 | return factor; 163 | } 164 | -------------------------------------------------------------------------------- /src/test.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | *************************************************************** 11 | * 12 | * test.h 13 | * 14 | * Created on: Dec 20, 2016 15 | * Author: zjr 16 | */ 17 | 18 | #ifndef TEST_H_ 19 | #define TEST_H_ 20 | 21 | #include "llvm/Pass.h" 22 | #include "llvm/IR/Function.h" 23 | #include "llvm/Support/raw_ostream.h" 24 | #include "llvm/Support/CFG.h" 25 | #include "llvm/Support/GraphWriter.h" 26 | #include "llvm/IR/Intrinsics.h" 27 | #include "llvm/Analysis/LoopInfo.h" 28 | #include "llvm/IR/Constants.h" 29 | #include "llvm/IR/Module.h" 30 | #include "llvm/IR/Instructions.h" 31 | #include "llvm/Support/SourceMgr.h" 32 | #include "llvm/IR/LLVMContext.h" 33 | #include "llvm/IRReader/IRReader.h" 34 | #include 35 | #include "llvm/ADT/Statistic.h" 36 | #include "llvm/Support/InstIterator.h" 37 | #include "llvm/IR/InstrTypes.h" 38 | #include "llvm/PassAnalysisSupport.h" 39 | #include 40 | #include 41 | #include 42 | #include 43 | #include 44 | #include 45 | #include 46 | #include 47 | #include 48 | 49 | using namespace llvm; 50 | 51 | typedef std::vector ivector; 52 | typedef std::vector > pvector; 53 | 54 | 55 | //User Defined: Input information according to applications 56 | //bicg 57 | #define d_num 5 //dim input size, equal to the number of array 58 | #define a_num 6 //dim*d_num, equal to the addition of all the dimensions 59 | #define l_num 2 //#depth*#loop_num 60 | #define f_num 1 //#functions 61 | /*//gemm 62 | #define d_num 3 //dim input size, equal to the number of array 63 | #define a_num 6 //dim*d_num, equal to the addition of all the dimensions 64 | #define l_num 4 //#depth*#loop_num 65 | #define f_num 1 66 | */ 67 | 68 | //Input variables 69 | extern int function_loop_num[]; 70 | extern int Loops_counter_input[]; 71 | extern int Loops_unroll_input[]; 72 | extern int Loops_pipeline_input[]; 73 | extern int array_partition_type[]; 74 | extern int array_partition_factor[]; 75 | extern int function_array_num[]; 76 | extern int array_size[]; 77 | extern int array_dimension[]; 78 | extern int function_pipeline_input[]; 79 | extern int dataflow_input[]; 80 | 81 | //Pragma setting 82 | extern std::map Function_dataflow; 83 | extern std::map Function_pipeline; 84 | extern std::map Loops_counter; 85 | extern std::map Loops_unroll; 86 | extern std::map Loops_pipeline; 87 | extern std::vector > array_partition[30]; //0:block, 1:cyclic; 88 | 89 | //Parameters 90 | extern std::map Load_latency; 91 | extern std::map Store_latency; 92 | extern std::map inst_reschedule_considered; 93 | extern std::map array_number; 94 | extern std::map bb_trip_counter; 95 | extern std::map loop_critical_path; 96 | extern std::vector Function_read_arg[30]; 97 | extern std::vector Function_write_arg[30]; 98 | extern std::vector Function_tmp_arg[30]; 99 | 100 | //Estimated performance 101 | extern std::map loop_cycles; 102 | extern std::map loop_II; 103 | extern std::map function_cycles; 104 | extern std::map function_II; 105 | extern std::map Function_index; 106 | 107 | //DSE parameters 108 | extern std::vector > function_subelement_cycles[30]; 109 | extern std::map array_map_array; 110 | extern std::vector loop_map_array[l_num]; 111 | extern std::map optimized_loops; 112 | extern std::map optimized_functions; 113 | extern std::vector > > loop_map_array_type[l_num]; 114 | 115 | 116 | class Configuration { 117 | public: 118 | Configuration(int num); 119 | void set_num_config(int num); 120 | int get_num_config(); 121 | void clear_config_vector(); 122 | void set_configuration(); 123 | void get_configuration(); 124 | void get_best_loop_unroll_pipeline(ivector &loop_unroll_vec,ivector &loop_pipeline_vec); 125 | void get_best_array_partition(pvector &array_partition_vec); 126 | void get_best_function_configuration(ivector &function_pipeline_vec,ivector &function_dataflow_vec); 127 | private: 128 | int config_num; 129 | ivector loop_unroll_config; 130 | ivector loop_pipeline_config; 131 | pvector array_partition_config; 132 | ivector function_pipeline_config; 133 | ivector dataflow_config; 134 | }; 135 | 136 | 137 | class Top_Results { 138 | public: 139 | std::map top_function_cycles; 140 | std::map top_function_II; 141 | std::map top_function_DSP; 142 | std::map top_function_BRAM; 143 | }; 144 | 145 | 146 | #endif /* TEST_H_ */ 147 | -------------------------------------------------------------------------------- /src/EvaluateDependency.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "EvaluateDependency.h" 15 | #include "ArrayName.h" 16 | #include "GEP.h" 17 | 18 | 19 | bool load_store_dependency(Instruction *inst_l, Instruction *inst_s) 20 | { 21 | bool LS_flag=false; 22 | Value *address_index_load=NULL; 23 | Value *address_index_store=NULL; 24 | address_index_store=get_array_name(inst_s); 25 | address_index_load=get_array_name(inst_l); 26 | 27 | if(address_index_store==address_index_load){ 28 | LS_flag=true; 29 | } 30 | return LS_flag; 31 | } 32 | 33 | 34 | bool store_store_dependency(Instruction *inst_s1, Instruction *inst_s2) 35 | { 36 | bool SS_flag=false; 37 | Value *address_index_s1=NULL; 38 | Value *address_index_s2=NULL; 39 | address_index_s1=get_array_name(inst_s1); 40 | address_index_s2=get_array_name(inst_s2); 41 | 42 | if(address_index_s1==address_index_s2){ 43 | SS_flag=true; 44 | } 45 | return SS_flag; 46 | } 47 | 48 | 49 | //Don't consider: if L has subloops, when it is unrolled, time should be addition.(seems like loop carried dependent) 50 | //Consider:when it is pipelined, subloops dependence will influence the latency and II. 51 | //Consider:if L has not subloops, this characteristic will influence the latency. 52 | bool test_loop_carried_dependence(LoopInfo* LI, Loop *L) 53 | { 54 | bool loop_carry=false; 55 | //int distance; 56 | //std::vector subLoops = L->getSubLoops(); 57 | BasicBlock *latch=L->getLoopLatch(); 58 | TerminatorInst *last_inst=latch->getTerminator(); 59 | BranchInst *br_inst=dyn_cast(last_inst); 60 | Instruction *indvar=NULL; 61 | if(br_inst != NULL){ 62 | CmpInst *cmp=dyn_cast(br_inst->getCondition()); 63 | Value *cmpOp0=cmp->getOperand(0); 64 | Value *cmpOp1=cmp->getOperand(1); 65 | if(Instruction *cmp_op0=dyn_cast(cmpOp0)) 66 | { 67 | indvar=cmp_op0; 68 | } 69 | else if(Instruction *cmp_op1=dyn_cast(cmpOp1)) 70 | { 71 | indvar=cmp_op1; 72 | } 73 | else{ 74 | errs()<<"Not a common conditional inst.\n"; 75 | } 76 | } 77 | PHINode *phi=NULL; 78 | BasicBlock *B1=*(L->block_begin()); 79 | for(auto j=B1->begin();j!=B1->end();++j){ 80 | bool break_flag=false; 81 | if(PHINode *phi1=dyn_cast(j)){ 82 | for(unsigned ii=0, ie=phi1->getNumIncomingValues();ii!=ie;ii++){ 83 | Value *incoming=phi1->getIncomingValue(ii); 84 | Instruction *inst1=dyn_cast(incoming); 85 | if(inst1==indvar){ 86 | phi=phi1; 87 | break_flag=true; 88 | break; 89 | } 90 | } 91 | if(break_flag==true){ 92 | break; 93 | } 94 | } 95 | } 96 | for(Loop::block_iterator BI=L->block_begin(), BE=L->block_end(); BI !=BE; ++BI) 97 | { 98 | BasicBlock *bb=*BI; 99 | for(auto iti=bb->begin();iti!=bb->end();++iti){ 100 | if(isa(iti)){ 101 | GetElementPtrInst *gep=get_GEP(iti); 102 | if(gep==NULL){ 103 | continue; 104 | } 105 | else{ 106 | int g_phi=get_gep_phi(gep,phi); 107 | if(g_phi==10){ 108 | continue;//second_iteration_flag=true; 109 | } 110 | else{ 111 | Value *g_op=gep->getOperand(g_phi); 112 | int compute_second=get_phi_second(L, phi); 113 | int second_iteration=compute_gep_operand(g_op,true,compute_second); 114 | for(Loop::block_iterator BL=L->block_begin(), BF=L->block_end(); BL !=BF; ++BL){ 115 | BasicBlock *BB=*BL; 116 | for(auto ii=BB->begin();ii!=BB->end();++ii){ 117 | if(isa(ii)){ 118 | bool ls_flag=load_store_dependency(iti,ii); 119 | if(ls_flag==true){ 120 | GetElementPtrInst *gep1=get_GEP(ii); 121 | if(gep1==NULL){ 122 | continue; 123 | } 124 | else{ 125 | int g_phi1=get_gep_phi(gep1,phi); 126 | if(g_phi1==10){ 127 | continue; 128 | } 129 | else{ 130 | Value *g_op1=gep->getOperand(g_phi1); 131 | int first_iteration1=compute_gep_operand(g_op1,false,0); 132 | if(second_iteration==first_iteration1){ 133 | return true; 134 | } 135 | } 136 | } 137 | } 138 | } 139 | } 140 | } 141 | } 142 | } 143 | } 144 | else if(CallInst *call=dyn_cast(iti)){ 145 | Function *callee=call->getCalledFunction(); 146 | unsigned FnID=callee->getIntrinsicID(); 147 | if(FnID==0){ 148 | unsigned num=call->getNumArgOperands(); 149 | for(unsigned op=0; opgetArgOperand(op); 151 | if(callee==OP){ 152 | errs()<<"The operand is the called function.\n"; 153 | } 154 | else{ 155 | for(Loop::block_iterator BL=L->block_begin(), BF=L->block_end(); BL !=BF; ++BL){ 156 | BasicBlock *BB=*BL; 157 | for(auto ii=BB->begin();ii!=BB->end();++ii){ 158 | if(isa(ii)){ 159 | Value *array=get_array_name(ii); 160 | if(OP==array){ 161 | return true; 162 | } 163 | } 164 | } 165 | } 166 | } 167 | } 168 | } 169 | } 170 | else continue; 171 | } 172 | } 173 | return loop_carry; 174 | } 175 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | COMBA 2 | ===================================== 3 | A Model-Based Analysis Framework for High Level Synthesis on FPGAs 4 | ------------------------------------- 5 | COMBA is used to estimate the performance of applications when applied with different pragma configurations in HLS tools, such as Vivado HLS. Another function of COMBA is that it can explore the design space quickly and find a high-performance configuration within minutes under given resource constraints. 6 | 7 | Please cite our paper if you find COMBA useful for your research: 8 | ``` 9 | @inproceedings{zhao2017comba, 10 | title={COMBA: A comprehensive model-based analysis framework for high level synthesis of real applications}, 11 | author={Zhao, Jieru and Feng, Liang and Sinha, Sharad and Zhang, Wei and Liang, Yun and He, Bingsheng}, 12 | booktitle={2017 IEEE/ACM International Conference on Computer-Aided Design (ICCAD)}, 13 | pages={430--437}, 14 | year={2017}, 15 | organization={IEEE} 16 | } 17 | ``` 18 | and 19 | ``` 20 | @article{zhao2019performance, 21 | title={Performance modeling and directives optimization for high level synthesis on fpga}, 22 | author={Zhao, Jieru and Feng, Liang and Sinha, Sharad and Zhang, Wei and Liang, Yun and He, Bingsheng}, 23 | journal={IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems}, 24 | year={2019}, 25 | publisher={IEEE} 26 | } 27 | ``` 28 | 29 | License: 30 | -------------------------------------- 31 | The source code is released under [GPLv3](https://www.gnu.org/licenses/licenses.en.html) license. 32 | If you have any questions about how to use our tool, please contact Jieru ZHAO (jzhaoao@connect.ust.hk). 33 | 34 | For commercial inqueries, please contact Prof. Wei ZHANG (wei.zhang@ust.hk). 35 | 36 | 37 | 38 | Building COMBA: 39 | -------------------------------------- 40 | 1. The platform we use is the LLVM compiler (Version 3.4) with the clang front-end. Please install it at first. 41 | The tool can be used directly on LLVM 3.4. 42 | 43 | 2. Put the whole folder of "COMBA" under "/llvm-3.4/lib/Transforms". 44 | 45 | 3. Add "add_subdirectory(COMBA)" in the "/llvm-3.4/lib/Transforms/CMakeLists.txt". 46 | 47 | 48 | 49 | Using COMBA: 50 | -------------------------------------- 51 | For testing given applications in the "test" folder (two steps): 52 | 1. To compile the source codes, run the bash file "runMyPro.sh". 53 | 54 | 2. To invoke the tool to analyze one application, run the command: 55 | ``` 56 | $ opt -load /llvm-3.4/Release+Asserts/lib/LLVMTest.so -test < ./test/$name.ll >/dev/null 57 | ``` 58 | $name.ll is the .ll file of the corresponding application, which is bicg.ll by default. 59 | 60 | For testing users' own applications (five steps): 61 | 1. To obtain the .ll file, run the command: 62 | ``` 63 | $ clang -O1 -emit-llvm -S $name.c -o $name.ll 64 | ``` 65 | $name.c is the application that you want to test and $name.ll is the corresponding .ll file. 66 | 67 | 2. Put the generated .ll file in the folder "test". 68 | 69 | 3. Modify the input of the tool as following: 70 | * In "/src/test.h", the values of four varibles (d_num, a_num, l_num and f_num) need to be modified. 71 | * d_num is the number of arrays in the top-function; 72 | * a_num is the sum of the number of dimension of each array; 73 | * l_num is the sum of loop levels of each loop; 74 | * f_num is the number of functions in this application. 75 | 76 | * In "/src/test.cpp", at the beginning of this file, five arrays (function_loop_num, Loops_counter_input, function_array_num, array_size and array_dimension) need to be initialized. 77 | * function_loop_num[i] is the number of loop levels in the (i+1)-th function. 78 | For example, if the second function in the application contains two 2-level nested loops, then function_loop_num[1] = 2*2 = 4. 79 | * Loops_counter_input[i] is the loop bound of the (i+1)-th loop. 80 | The order of loops is counted from the first loop to the next loop and from the outer level to the inner level. You can see the function "set_loop_counter_ul_pipeline" in "SetPragma.cpp" to learn the details if you want. 81 | * function_array_num[i] is the number of arrays in the (i+1)-th function. 82 | * array_size[i] is the number of array elements in the (i+1)-th array dimension. 83 | For example, if there are three arrays A[8], B[16], C[4][8] and their order is A, C, B, then array_size[0] = 8, array_size[1] = 4 (row), array_size[2] = 8 (column) and array_size[3] = 16. 84 | Note that the order of arrays depends on its order of appearance in the LLVM IR (.ll file). If you don't want to look at the control flow graph or check the .ll file, you can also get this information by removing the annotation symbols at the end of the function "set_array_index" in "SetParameter.cpp", doing the rest two steps, exiting the process after getting the information and then come back to this step to finish the input setting. 85 | * array_dimension[i] is the number of dimension of the (i+1)-th array. 86 | 87 | * In "/src/test.cpp", the other six arrays, Loops_unroll_input[l_num], Loops_pipeline_input[l_num], array_partition_type[a_num], array_partition_factor[a_num], function_pipeline_input[f_num] and dataflow_input[f_num], are the configuration of the beginning point (no pragma is applied). Therefore, initialize them to 0 or 1 (loop/function pipelining and dataflow are 0 and others are 1). 88 | 89 | 4. To compile the source codes, run the bash file "runMyPro.sh". 90 | 5. To invoke the tool to analyze the application, run the command: 91 | ``` 92 | $ opt -load /llvm-3.4/Release+Asserts/lib/LLVMTest.so -test < ./test/$name.ll >/dev/null 93 | ``` 94 | 95 | Notes: 96 | -------------------------------------- 97 | The characterization library in the current version of COMBA is based on Xilinx Vivado HLS 2016.1. 98 | -------------------------------------------------------------------------------- /src/Dataflow_II.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "Dataflow_II.h" 15 | #include "LoopInterface.h" 16 | #include "ArrayName.h" 17 | 18 | 19 | bool check_dataflow(Function *F, LoopInfo* LI) 20 | { 21 | std::map Dataflow_read_num; 22 | std::map Dataflow_write_num; 23 | //Dataflow_read_num.clear(); 24 | //Dataflow_write_num.clear(); 25 | bool bb_in_loop=false; 26 | //std::queue rw_queue; 27 | int sub_element_num=0; 28 | for(auto itb=F->begin();itb!=F->end();++itb) 29 | { 30 | for(LoopInfo::iterator i=LI->begin(),e=LI->end();i!=e;++i) 31 | { 32 | Loop *L=*i; 33 | if(L->contains(itb)){ 34 | bb_in_loop=true; 35 | break; 36 | } 37 | } 38 | if(bb_in_loop==false){ 39 | for(auto iti=itb->begin();iti!=itb->end();++iti){ 40 | if(CallInst *call=dyn_cast(iti)){ 41 | Function *callee=call->getCalledFunction(); 42 | unsigned id=callee->getIntrinsicID(); 43 | if(id==0){ 44 | unsigned f_index=Function_index[callee]; 45 | for(std::vector::iterator i=Function_read_arg[f_index].begin(); i!=Function_read_arg[f_index].end(); ++i) 46 | { 47 | unsigned argno=*i; 48 | Value *call_read=call->getArgOperand(argno); 49 | if(Dataflow_read_num.count(call_read)){ 50 | Dataflow_read_num[call_read]++; 51 | } 52 | else{ 53 | Dataflow_read_num[call_read]=1; 54 | } 55 | } 56 | for(std::vector::iterator i=Function_write_arg[f_index].begin(); i!=Function_write_arg[f_index].end(); ++i) 57 | { 58 | unsigned argno=*i; 59 | Value *call_write=call->getArgOperand(argno); 60 | if(Dataflow_write_num.count(call_write)){ 61 | Dataflow_write_num[call_write]++; 62 | } 63 | else{ 64 | Dataflow_write_num[call_write]=1; 65 | } 66 | } 67 | sub_element_num++; 68 | } 69 | } 70 | } 71 | } 72 | } 73 | for(LoopInfo::iterator i=LI->begin(),e=LI->end();i!=e;++i) 74 | { 75 | Loop *L=*i; 76 | std::vector loop_read; 77 | std::vector loop_write; 78 | get_loop_input(L,loop_read); 79 | get_loop_output(L,loop_write); 80 | for(std::vector::iterator i=loop_read.begin();i!=loop_read.end();++i) 81 | { 82 | Value *read=*i; 83 | if(Dataflow_read_num.count(read)){ 84 | Dataflow_read_num[read]++; 85 | } 86 | else{ 87 | Dataflow_read_num[read]=1; 88 | } 89 | } 90 | for(std::vector::iterator i=loop_write.begin();i!=loop_write.end();++i) 91 | { 92 | Value *write=*i; 93 | if(Dataflow_write_num.count(write)){ 94 | Dataflow_write_num[write]++; 95 | } 96 | else{ 97 | Dataflow_write_num[write]=1; 98 | } 99 | } 100 | sub_element_num++; 101 | } 102 | //No need to dataflow if only one sub-element 103 | if(sub_element_num<=1){ 104 | return false; 105 | } 106 | for(std::map::iterator d=Dataflow_read_num.begin();d!=Dataflow_read_num.end();++d) 107 | { 108 | int num=d->second; 109 | if(num>1){ 110 | Value *array_read=d->first; 111 | if(Dataflow_write_num.count(array_read)){ 112 | return false; 113 | } 114 | //errs()<<"No dataflow: Array is read by more than one functions.\n"; 115 | } 116 | } 117 | for(std::map::iterator d=Dataflow_write_num.begin();d!=Dataflow_write_num.end();++d) 118 | { 119 | int num=d->second; 120 | if(num>1){ 121 | //errs()<<"No dataflow: Array is written by more than one functions.\n"; 122 | return false; 123 | } 124 | } 125 | //if load a and store a, should be load a->store in the same loop, or store a and then load it next, otherwise false... 126 | int inst_index=0; 127 | for(inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I){ 128 | Instruction *inst=&*I; 129 | if(isa(inst)){ 130 | Value *array_store=get_array_name(inst); 131 | int inst1_index=0; 132 | for(inst_iterator II = inst_begin(F), IE = inst_end(F); II != IE; ++II){ 133 | Instruction *inst1=&*II; 134 | if(isa(inst1)){ 135 | Value *array_load=get_array_name(inst1); 136 | if(array_store==array_load){ 137 | if(inst1_indexgetParent(); 139 | BasicBlock *bb_store=inst->getParent(); 140 | if(bb_load!=bb_store){ 141 | Loop *l_load; 142 | Loop *l_store; 143 | for(LoopInfo::iterator i=LI->begin(),e=LI->end();i!=e;++i) 144 | { 145 | Loop *L=*i; 146 | if(L->contains(bb_load)){ 147 | l_load=L; 148 | } 149 | if(L->contains(bb_store)){ 150 | l_store=L; 151 | } 152 | } 153 | if(l_load!=l_store){ 154 | return false; 155 | } 156 | } 157 | } 158 | } 159 | } 160 | inst1_index++; 161 | } 162 | } 163 | inst_index++; 164 | } 165 | 166 | return true; 167 | } 168 | 169 | int compute_dataflow_II(Function *F, LoopInfo* LI) 170 | { 171 | int II=1; 172 | bool bb_in_loop=false; 173 | for(auto itb=F->begin();itb!=F->end();++itb) 174 | { 175 | for(LoopInfo::iterator i=LI->begin(),e=LI->end();i!=e;++i) 176 | { 177 | Loop *L=*i; 178 | if(L->contains(itb)){ 179 | bb_in_loop=true; 180 | break; 181 | } 182 | } 183 | if(bb_in_loop==false){ 184 | for(auto iti=itb->begin();iti!=itb->end();++iti){ 185 | if(CallInst *call=dyn_cast(iti)){ 186 | Function *callee=call->getCalledFunction(); 187 | unsigned FnID=callee->getIntrinsicID(); 188 | if(FnID==0){ 189 | int m=0; 190 | if(Function_pipeline[F]==1){ 191 | m=function_II[callee]; 192 | } 193 | else{ 194 | m=function_cycles[callee]; 195 | } 196 | II=std::max(m,II); 197 | } 198 | } 199 | } 200 | } 201 | } 202 | for(LoopInfo::reverse_iterator i=LI->rbegin(),e=LI->rend();i!=e;++i) 203 | { 204 | Loop *L=*i; 205 | int n=0; 206 | n=(int)loop_cycles[L]; 207 | II=std::max(n,II); 208 | } 209 | return II; 210 | } 211 | -------------------------------------------------------------------------------- /src/Library.h: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | /* 15 | * Library.h 16 | */ 17 | #ifndef LIBRARY_H_ 18 | #define LIBRARY_H_ 19 | 20 | /* Default to 100 MHz. */ 21 | #if !defined(FREQUENCY100) && !defined(FREQUENCY125) && !defined(FREQUENCY150) && !defined(FREQUENCY200) && !defined(FREQUENCY250) 22 | # define FREQUENCY100 23 | #endif 24 | 25 | #ifdef FREQUENCY100 26 | //T=10ns, F=100MHz //(reschedule and library finished) 27 | # define frequency 100 //load,store can deduct some value(large latency, load not chain with small ops). imult chain with add but not write, intdiv and idiv chain with add, write.. can choose suitable library. 28 | # define INT_ADD 0.2 29 | # define INT_MULT 1.4 //actual 1.0, cannot chain with load and store. cannot chain with small operations either. 30 | # define IMULT 6.0 //actual 6.0, can chain with load and store, also small operations. not small and store/load together. not other large operations. 31 | # define INT_DIV 7.0 //actual 7.0, same with imult. 32 | # define IDIV 34.0 //actual 36.0, same with imult, but can chain with small and store together. not chain with other large operations. 33 | # define U_DIV 6.0 34 | # define UDIV 34.0 35 | # define FP_ADD 4.0 //not chain 36 | # define FP_MULT 3.0 //not chain 37 | # define FP_DIV 10.0 //not chain 38 | # define SI_TO_FP 4.0 //can chain 39 | # define FP_TO_SI 1.0 40 | # define SHIFT 0.05 41 | # define ALLOCA_LATENCY 1.0 42 | # define GEP_LATENCY 0.0 43 | # define CAST_LATENCY 0.2 44 | # define PHI_LATENCY 1.5//1.0 45 | # define ICMP_LATENCY 0.15 46 | # define FCMP_LATENCY 4.0 47 | # define SELECT_LATENCY 0.05 48 | # define CALL_LATENCY 1.0 49 | #endif 50 | 51 | 52 | #ifdef FREQUENCY125 53 | //T=8ns, F=125MHz //(reschedule and library finished) 54 | # define frequency 125 //load, store, large operations can chain with small operations. 55 | # define INT_ADD 0.3 56 | # define INT_MULT 3.0 //chain with small operations. cannot chain with load and store. 57 | # define IMULT 6.0 //same with int_mult 58 | # define INT_DIV 7.0 //same with imult 59 | # define IDIV 35.0 //actual 36.0, can chain with load and store 60 | # define U_DIV 6.0 //same with imult 61 | # define UDIV 35.0 //actual 36.0, can chain with load and store 62 | # define FP_ADD 5.0 //not chain 63 | # define FP_MULT 3.0 //actual 4.0, can chain with load and store 64 | # define FP_DIV 12.0 //not chain 65 | # define SI_TO_FP 4.0 //not chain 66 | # define FP_TO_SI 1.0 //not chain 67 | # define SHIFT 0.1//0.05 68 | # define ALLOCA_LATENCY 1.0 69 | # define GEP_LATENCY 0.0 70 | # define CAST_LATENCY 0.2 71 | # define PHI_LATENCY 1.5//1.0 72 | # define ICMP_LATENCY 0.3 73 | # define FCMP_LATENCY 5.0 74 | # define SELECT_LATENCY 0.1 75 | # define CALL_LATENCY 1.0 76 | #endif 77 | 78 | 79 | #ifdef FREQUENCY150 80 | //T=6.67ns, F=150MHz //(reschedule and library finished) 81 | # define frequency 150 //load and write can only chain when there is a shift. 82 | # define INT_ADD 0.3 83 | # define INT_MULT 3.0 //actual:3.0, not chain 84 | # define IMULT 6.0 //actual:6.0, not chain 85 | # define INT_DIV 7.0 //actual:7.0, not chain, chain with shift 86 | # define IDIV 36.0 //not chain with load/store/large operations, but chain with small operations 87 | # define U_DIV 6.0 //actual:6.0, not chain 88 | # define UDIV 36.0 //same with idiv 89 | # define FP_ADD 7.0 //actual:7.0, not chain 90 | # define FP_MULT 4.0 //actual:4.0, not chain 91 | # define FP_DIV 13.0 //actual:13.0, not chain 92 | # define SI_TO_FP 5.0 93 | # define FP_TO_SI 1.7 //actual:2.0, chain with write, not add+write 94 | # define SHIFT 0.1 95 | # define ALLOCA_LATENCY 1.0 96 | # define GEP_LATENCY 0.0 97 | # define CAST_LATENCY 0.2 98 | # define PHI_LATENCY 1.5//1.0 99 | # define ICMP_LATENCY 0.3 100 | # define FCMP_LATENCY 7.0 101 | # define SELECT_LATENCY 0.1 102 | # define CALL_LATENCY 1.0 103 | #endif 104 | 105 | 106 | #ifdef FREQUENCY200 107 | //T=5ns, F=200MHz //(reschedule and library finished) 108 | # define frequency 200 //100,300,400 109 | # define INT_ADD 0.5 110 | # define INT_MULT 5.0 //actual 5.0 //load and write can be chained with mul,etc. Therefore estimate the effective latency. 111 | # define IMULT 7.0 //actual 7.0 112 | # define INT_DIV 8.0 //actual 8.0 //div can chain with load, cannot chain with other operations. 113 | # define IDIV 36.0 //not chain 114 | # define U_DIV 7.0 //actual 7.0 same with imul 115 | # define UDIV 36.0 116 | # define FP_ADD 8.0 //not chain 117 | # define FP_MULT 5.0 //not chain 118 | # define FP_DIV 16.0 //not chain 119 | # define SI_TO_FP 6.0 120 | # define FP_TO_SI 2.5 //after casting, there is a select for div, so add 0.5. 121 | # define SHIFT 0.2 122 | # define ALLOCA_LATENCY 1.0 123 | # define GEP_LATENCY 1.0 124 | # define CAST_LATENCY 0.4 125 | # define PHI_LATENCY 1.5 126 | # define ICMP_LATENCY 0.5 127 | # define FCMP_LATENCY 8.0//0.5 128 | # define SELECT_LATENCY 0.2 129 | # define CALL_LATENCY 1.0 130 | #endif 131 | 132 | 133 | #ifdef FREQUENCY250 134 | //T=4ns, F=250MHz //(reschedule and library finished) 135 | # define frequency 250 //load, store cannot chain. large operations can chain with small operations. 136 | # define INT_ADD 0.5 137 | # define INT_MULT 5.0 //chain with small operations 138 | # define IMULT 7.0 //same with int_mult 139 | # define INT_DIV 9.0 //before chain, after not chain 140 | # define IDIV 36.1 //not chain, add 0.2 affect "add,DIV,add" situation. 141 | # define U_DIV 7.0 //same with imult 142 | # define UDIV 36.1 //not chain 143 | # define FP_ADD 9.1 //not chain 144 | # define FP_MULT 6.1 145 | # define FP_DIV 30.1 146 | # define SI_TO_FP 8.1 147 | # define FP_TO_SI 3.1 148 | # define SHIFT 0.2 149 | # define ALLOCA_LATENCY 1.0 150 | # define GEP_LATENCY 1.0 151 | # define CAST_LATENCY 0.5 152 | # define PHI_LATENCY 1.5 153 | # define ICMP_LATENCY 0.5 154 | # define FCMP_LATENCY 9.0//0.5 155 | # define SELECT_LATENCY 0.2 156 | # define CALL_LATENCY 1.0 157 | #endif 158 | 159 | 160 | #endif /* LIBRARY_H_ */ 161 | -------------------------------------------------------------------------------- /src/FindLatency.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "FindLatency.h" 15 | #include "Constant.h" 16 | #include "ComputeCriticalPath.h" 17 | 18 | float find_latency_before_inst(Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop) 19 | { 20 | float latency=0.0; 21 | std::map loop_inst_till_latency; 22 | float cp=loop_solveCP(dependence_loop,loop_inst_till_latency); 23 | if(cp<0.0){ 24 | errs()<<"Please check1...\n"; 25 | } 26 | for(unsigned op=0;op!=inst->getNumOperands();++op) 27 | { 28 | Value *OP = inst->getOperand(op); 29 | if(Instruction *inst1 = dyn_cast(OP)){ 30 | if(instr_index_loop.count(inst1)){ 31 | unsigned index_inst1=instr_index_loop[inst1]; 32 | latency=std::max(latency,loop_inst_till_latency[index_inst1]); 33 | } 34 | } 35 | } 36 | //for PHI and load/write instructions, we add "manual dependence" when considering relationship between blocks. Here, we just consider load due to our needs. 37 | if(isa(inst)){ 38 | if(instr_index_loop.count(inst)){ 39 | unsigned inst_index=instr_index_loop[inst]; 40 | for(std::map::iterator it=instr_index_loop.begin();it!=instr_index_loop.end();++it){ 41 | unsigned inst_tmp_index=it->second; 42 | for(std::vector< std::pair >::iterator i= dependence_loop[inst_tmp_index].begin(); i!=dependence_loop[inst_tmp_index].end(); ++i){ 43 | if(i->first==(int)inst_index){ 44 | float latency_tmp=loop_inst_till_latency[inst_tmp_index]; 45 | latency=std::max(latency,latency_tmp); 46 | } 47 | } 48 | } 49 | } 50 | } 51 | return round(latency); 52 | } 53 | 54 | 55 | float find_latency_after_inst(Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop) 56 | { 57 | float latency=0.0; 58 | std::map loop_inst_till_latency; 59 | float cp=loop_solveCP(dependence_loop,loop_inst_till_latency); 60 | if(cp<0.0){ 61 | errs()<<"Please check2...\n"; 62 | } 63 | unsigned index_inst=instr_index_loop[inst]; 64 | latency=loop_inst_till_latency[index_inst]; 65 | return round(latency); 66 | } 67 | 68 | 69 | float find_latency(Instruction *inst_begin, Instruction *inst_end, std::map &instr_index_loop, std::vector > *dependence_loop) 70 | { 71 | std::queue index_queue[INSN_NUM]; 72 | float latency=0.0; 73 | unsigned index_inst_begin=instr_index_loop[inst_begin]; 74 | unsigned index_inst_end=instr_index_loop[inst_end]; 75 | float *T=new float [INSN_NUM]; 76 | for (int i=0;i pushed_inst; 79 | if(!dependence_loop[index_inst_begin].empty()) 80 | { 81 | for(std::vector< std::pair >::iterator i= dependence_loop[index_inst_begin].begin(); i!=dependence_loop[index_inst_begin].end(); ++i) 82 | { 83 | if(i->first==(int)index_inst_begin) 84 | { 85 | if(isa(inst_begin)){ 86 | latency = 2.0; 87 | } 88 | else if(PHINode *phi=dyn_cast(inst_begin)){ 89 | for(unsigned ii=0,ie=phi->getNumIncomingValues();ii!=ie;ii++){ 90 | Value *incoming=phi->getIncomingValue(ii); 91 | if(isa(incoming)){ 92 | latency = 2.0; 93 | break; 94 | } 95 | else{ 96 | latency = std::max(i->second, latency); 97 | } 98 | } 99 | } 100 | else{ 101 | latency = std::max(i->second, latency); 102 | } 103 | T[index_inst_begin]=latency; 104 | continue; 105 | } 106 | else{ 107 | if(!pushed_inst.count((int)index_inst_begin)){ 108 | int index_tmp=i->first; 109 | float latency_tmp=i->second; 110 | T[index_tmp]=T[index_inst_begin]+latency_tmp; 111 | index_queue[index_inst_begin].push(index_tmp); 112 | pushed_inst[index_inst_begin]=1; 113 | } 114 | else{ 115 | int index_tmp=i->first; 116 | float latency_tmp=i->second; 117 | float T_tmp=T[index_inst_begin]+latency_tmp; 118 | T[index_tmp]=std::max(T_tmp,T[index_tmp]); 119 | } 120 | } 121 | } 122 | } 123 | for(int j=index_inst_begin; j<= (int)index_inst_end; ++j) 124 | { 125 | while(!index_queue[j].empty()) 126 | { 127 | int index_test=index_queue[j].front(); 128 | index_queue[j].pop(); 129 | for(std::vector< std::pair >::iterator i= dependence_loop[index_test].begin(); i!=dependence_loop[index_test].end(); ++i) 130 | { 131 | float tmp=0.0; 132 | if(i->first==index_test){ 133 | tmp = T[index_test] + i->second; 134 | T[index_test]=std::max(tmp,T[index_test]); 135 | } 136 | else{ 137 | if(!pushed_inst.count(index_test)){ 138 | int index_tmp=i->first; 139 | float latency_tmp=i->second; 140 | T[index_tmp]=T[index_test]+latency_tmp; 141 | index_queue[index_test].push(index_tmp); 142 | } 143 | else{ 144 | int index_tmp=i->first; 145 | float latency_tmp=i->second; 146 | float T_tmp=T[index_test]+latency_tmp; 147 | T[index_tmp]=std::max(T_tmp,T[index_tmp]); 148 | } 149 | } 150 | } 151 | } 152 | } 153 | 154 | if(T[index_inst_end] == 0.0){ 155 | //errs()<<"These two instruction have no dependency\n"; 156 | latency=0.0; 157 | } 158 | else{ 159 | latency=T[index_inst_end]; 160 | } 161 | delete []T; 162 | return latency; 163 | } 164 | 165 | float get_inst_latency(Instruction *inst, std::map &instr_index_loop,std::vector > *dependence_loop) 166 | { 167 | float latency=0.0; 168 | if(instr_index_loop.count(inst)){ 169 | unsigned index=instr_index_loop[inst]; 170 | for(std::vector >::iterator i=dependence_loop[index].begin();i!=dependence_loop[index].end();++i){ 171 | if((i->first==(int)index)){ 172 | latency=i->second; 173 | } 174 | } 175 | } 176 | return latency; 177 | } 178 | 179 | void set_inst_latency(Instruction *inst,float latency,std::map &instr_index_loop,std::vector > *dependence_loop) 180 | { 181 | if(instr_index_loop.count(inst)){ 182 | unsigned index=instr_index_loop[inst]; 183 | for(std::vector >::iterator i=dependence_loop[index].begin();i!=dependence_loop[index].end();++i){ 184 | if((i->first==(int)index)){ 185 | i->second=latency; 186 | } 187 | } 188 | } 189 | } 190 | -------------------------------------------------------------------------------- /src/MemOpNum.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "MemOpNum.h" 15 | #include "ArrayName.h" 16 | #include "GEP.h" 17 | #include "LoopUnrollFactor.h" 18 | #include "PartitionNum.h" 19 | #include "ComputeMemLatency.h" 20 | 21 | int compute_BB_load_num(BasicBlock *itb, Instruction *inst) 22 | { 23 | int load_num=1; 24 | Value *address_index_tmp=NULL; 25 | Value *address_index=NULL; 26 | 27 | address_index=get_array_name(inst); 28 | GetElementPtrInst *gep1=get_GEP(inst); 29 | for(auto iti=itb->begin(); iti!=itb->end();++iti) 30 | { 31 | if(isa(iti)) 32 | { 33 | address_index_tmp=get_array_name(iti); 34 | if(address_index_tmp==address_index) 35 | { 36 | GetElementPtrInst *gep=get_GEP(iti); 37 | if(gep!=gep1){ 38 | load_num++; 39 | } 40 | } 41 | } 42 | } 43 | return load_num; 44 | } 45 | 46 | int compute_BB_store_num(BasicBlock *itb, Instruction *inst) 47 | { 48 | int store_num=1; 49 | Value *address_index_tmp=NULL; 50 | Value *address_index=NULL; 51 | 52 | address_index=get_array_name(inst); 53 | GetElementPtrInst *gep1=get_GEP(inst); 54 | for(auto iti=itb->begin(); iti!=itb->end();++iti) 55 | { 56 | if(isa(iti)) 57 | { 58 | address_index_tmp=get_array_name(iti); 59 | if(address_index_tmp==address_index) 60 | { 61 | GetElementPtrInst *gep=get_GEP(iti); 62 | if(gep!=gep1){ 63 | store_num++; 64 | } 65 | } 66 | } 67 | } 68 | return store_num; 69 | } 70 | 71 | int partition_mem_op_num(LoopInfo *LI, BasicBlock *bb, Instruction *inst) 72 | { 73 | int num=0; 74 | Value *array_name=get_array_name(inst); 75 | bool inst_is_load=false; 76 | bool inst_is_store=false; 77 | bool both_are_load=false; 78 | bool both_are_store=false; 79 | std::vector array_element_counted; 80 | GetElementPtrInst *gep1=get_GEP(inst); 81 | Loop *L=LI->getLoopFor(bb); 82 | int inst_offset=0; 83 | int same_bank_factor=1; 84 | bool has_same=false; 85 | if(gep1!=NULL){ 86 | for(User::op_iterator ii=gep1->idx_begin(), ie=gep1->idx_end();ii!=ie; ++ii){ 87 | Value *op_l=*ii; 88 | if(Instruction *op_inst=dyn_cast(op_l)){ 89 | BasicBlock *bb1=op_inst->getParent(); 90 | Loop *l1=LI->getLoopFor(bb1); 91 | bool related=unroll_loop_relation(L,l1); 92 | if(related==true){ 93 | int a=get_unroll_SameBank_num(bb1,inst,inst,array_element_counted); 94 | //errs()<<"a: "<getParent(); 104 | Loop *l1=LI->getLoopFor(bb1); 105 | bool related=unroll_loop_relation(L,l1); 106 | if(related==true){ 107 | int a=get_unroll_SameBank_num(bb1,inst,inst,array_element_counted); 108 | if(a!=0){ 109 | same_bank_factor *= a; 110 | has_same=true; 111 | } 112 | inst_offset=compute_array_element_offset(inst,bb1,0); 113 | } 114 | } 115 | } 116 | } 117 | if(has_same==true){ 118 | num += same_bank_factor; 119 | } 120 | array_element_counted.push_back(inst_offset); 121 | 122 | if(isa(inst)){ 123 | inst_is_load=true; 124 | } 125 | else if(isa(inst)){ 126 | inst_is_store=true; 127 | } 128 | else{ 129 | errs()<<"This inst is neither load nor store.\n"; 130 | } 131 | for(auto iti=bb->begin();iti!=bb->end();++iti){ 132 | both_are_load=inst_is_load && (isa(iti)); 133 | both_are_store=inst_is_store && (isa(iti)); 134 | if(both_are_load || both_are_store){ 135 | Value *array_name_tmp=get_array_name(iti); 136 | if(array_name==array_name_tmp){ 137 | GetElementPtrInst *gep=get_GEP(iti); 138 | if(gep!=gep1){ 139 | if(gep!=NULL){ 140 | int same_factor=1; 141 | bool have_same=false; 142 | for(User::op_iterator ii=gep->idx_begin(), ie=gep->idx_end();ii!=ie; ++ii){ 143 | Value *op_l=*ii; 144 | if(Instruction *op_inst=dyn_cast(op_l)){ 145 | BasicBlock *bb2=op_inst->getParent(); 146 | Loop *l2=LI->getLoopFor(bb2); 147 | bool related=unroll_loop_relation(L,l2); 148 | if(related==true){ 149 | int b=get_unroll_SameBank_num(bb2,inst,iti,array_element_counted); 150 | if(b!=0){ 151 | same_factor *= b; 152 | have_same=true; 153 | } 154 | } 155 | } 156 | else{ 157 | BasicBlock *bb2=gep->getParent(); 158 | Loop *l2=LI->getLoopFor(bb2); 159 | bool related=unroll_loop_relation(L,l2); 160 | if(related==true){ 161 | int b=get_unroll_SameBank_num(bb2,inst,iti,array_element_counted); 162 | if(b!=0){ 163 | same_factor *= b; 164 | have_same=true; 165 | } 166 | } 167 | } 168 | } 169 | if(have_same==true){ 170 | num += same_factor; 171 | } 172 | } 173 | } 174 | } 175 | } 176 | } 177 | if(num==0){ 178 | num=1; 179 | } 180 | return num; 181 | } 182 | 183 | int compute_total_LS_num(LoopInfo* LI, Instruction *inst) 184 | { 185 | if((!isa(inst))&&(!isa(inst))){ 186 | errs()<<"This instruction is neither load nor store...Not apply.\n"; 187 | } 188 | int num=0; 189 | bool array_partition_is_set=false; 190 | BasicBlock *bb=inst->getParent(); 191 | int unroll_factor=0; 192 | Loop *L=LI->getLoopFor(bb); 193 | unroll_factor=total_unroll_factor_ls(LI,L,inst); 194 | Value *array_name=get_array_name(inst); 195 | int size=1; 196 | if(array_number.count(array_name)){ 197 | int array_index=array_number[array_name]; 198 | int dim=array_dimension[array_index]; 199 | int initial=0; 200 | for(int j=0; j >::iterator it= array_partition[array_index].begin(); it!=array_partition[array_index].end(); ++it) 208 | { 209 | if(it->second!=1){ 210 | array_partition_is_set=true; 211 | break; 212 | } 213 | } 214 | } 215 | if(array_partition_is_set==false){ 216 | if(isa(inst)){ 217 | num=compute_BB_load_num(bb,inst)*unroll_factor; 218 | if(num>size){ 219 | num=size; 220 | } 221 | } 222 | else if(isa(inst)){ 223 | num=compute_BB_store_num(bb,inst)*unroll_factor; 224 | } 225 | } 226 | else{ 227 | num=partition_mem_op_num(LI,bb,inst)+(int)mux_latency(LI,bb,inst)*2; 228 | } 229 | return num; 230 | } 231 | -------------------------------------------------------------------------------- /src/InstLibrary.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "InstLibrary.h" 15 | #include "Library.h" 16 | #include "Power.h" 17 | 18 | float inst_latency_in_library(Instruction *inst) 19 | { 20 | float latency=0.0; 21 | switch(inst->getOpcode()){ 22 | //Terminator Instructions 23 | case Instruction::Ret: 24 | case Instruction::Br: 25 | case Instruction::Switch: 26 | case Instruction::IndirectBr: 27 | case Instruction::Invoke: 28 | case Instruction::Resume: 29 | case Instruction::Unreachable: 30 | break; 31 | //Standard binary operators 32 | case Instruction::Add: 33 | case Instruction::Sub: 34 | latency=INT_ADD; 35 | break; 36 | case Instruction::FAdd: 37 | case Instruction::FSub: 38 | latency=FP_ADD; 39 | break; 40 | case Instruction::Mul: 41 | Value *opr0; 42 | opr0=inst->getOperand(1); 43 | if(ConstantInt *cont=dyn_cast(opr0)){ 44 | int opconst=cont->getSExtValue(); 45 | if(is_power_of_two(opconst)){ 46 | latency=SHIFT; 47 | //errs()<<"Ignored: multiplied by a contant which is power of two.\n"; 48 | } 49 | else{ 50 | float SHL_ADD=0.0; 51 | if(frequency==100){ 52 | SHL_ADD=SHIFT+INT_ADD; 53 | } 54 | else if(frequency==125){ 55 | SHL_ADD=SHIFT+INT_ADD; 56 | } 57 | else if(frequency==150){ 58 | SHL_ADD=SHIFT+INT_ADD; 59 | } 60 | else if(frequency==200){ 61 | SHL_ADD=SHIFT+INT_ADD; 62 | } 63 | else if(frequency==250){ 64 | SHL_ADD=SHIFT+INT_ADD+0.2; 65 | } 66 | int bound_power_two=closest_bound_power_two(opconst); 67 | if(opconst<0){ 68 | opconst=-opconst; 69 | } 70 | int delta=opconst-bound_power_two; 71 | if(delta<0){ 72 | delta=-delta; 73 | } 74 | if(delta==1){ 75 | latency=SHL_ADD; 76 | } 77 | else{ 78 | if(is_power_of_two(delta)){ 79 | latency=SHL_ADD; 80 | } 81 | else{ 82 | latency=INT_MULT; 83 | } 84 | } 85 | } 86 | } 87 | else{ 88 | latency=IMULT; 89 | } 90 | break; 91 | case Instruction::FMul: 92 | latency=FP_MULT; 93 | break; 94 | case Instruction::SDiv: 95 | case Instruction::SRem: 96 | Value *opr; 97 | opr=inst->getOperand(1); 98 | if(ConstantInt *cont=dyn_cast(opr)){ 99 | int opconst=cont->getSExtValue(); 100 | if(is_power_of_two(opconst)){ 101 | float SHL_DIV=0.0; 102 | if(frequency==100){ 103 | SHL_DIV=SELECT_LATENCY+2*INT_ADD; 104 | } 105 | else if(frequency==125){ 106 | SHL_DIV=SELECT_LATENCY+2*INT_ADD; 107 | } 108 | else if(frequency==150){ 109 | SHL_DIV=SELECT_LATENCY+2*INT_ADD; 110 | } 111 | else if(frequency==200){ 112 | SHL_DIV=SELECT_LATENCY+INT_ADD; 113 | } 114 | else if(frequency==250){ 115 | SHL_DIV=SELECT_LATENCY+INT_ADD; 116 | } 117 | latency=SHL_DIV; 118 | //errs()<<"Ignored: Divided by a contant which is power of two.\n"; 119 | } 120 | else{ 121 | latency=INT_DIV; 122 | } 123 | } 124 | else{ 125 | latency=IDIV; 126 | } 127 | break; 128 | case Instruction::UDiv: 129 | case Instruction::URem: 130 | Value *opr1; 131 | opr1=inst->getOperand(1); 132 | if(ConstantInt *cont=dyn_cast(opr1)){ 133 | int opconst=cont->getSExtValue(); 134 | if(is_power_of_two(opconst)){ 135 | float SHL_DIV=0.0; 136 | if(frequency==100){ 137 | SHL_DIV=SELECT_LATENCY+2*INT_ADD; 138 | } 139 | else if(frequency==125){ 140 | SHL_DIV=SELECT_LATENCY+2*INT_ADD; 141 | } 142 | else if(frequency==150){ 143 | SHL_DIV=SELECT_LATENCY+INT_ADD; 144 | } 145 | else if(frequency==200){ 146 | SHL_DIV=SELECT_LATENCY+INT_ADD; 147 | } 148 | else if(frequency==250){ 149 | SHL_DIV=SELECT_LATENCY+INT_ADD; 150 | } 151 | latency=SHL_DIV; 152 | //errs()<<"Ignored: Divided by a contant which is power of two.\n"; 153 | } 154 | else{ 155 | latency=U_DIV; 156 | } 157 | } 158 | else{ 159 | latency=UDIV; 160 | } 161 | break; 162 | case Instruction::FDiv: 163 | case Instruction::FRem: 164 | latency=FP_DIV; 165 | break; 166 | 167 | //Logical operators (integer operands) 168 | case Instruction::Shl: 169 | case Instruction::LShr: 170 | case Instruction::AShr: 171 | latency=SHIFT; 172 | break; 173 | case Instruction::And: 174 | case Instruction::Or: 175 | case Instruction::Xor: 176 | latency=INT_ADD; 177 | break; 178 | //Memory operators 179 | case Instruction::Alloca: 180 | latency=ALLOCA_LATENCY; 181 | break; 182 | case Instruction::Load: 183 | case Instruction::Store: 184 | break; 185 | 186 | case Instruction::GetElementPtr: 187 | latency=GEP_LATENCY; 188 | break; 189 | 190 | case Instruction::Fence: break; 191 | case Instruction::AtomicCmpXchg: break; 192 | case Instruction::AtomicRMW: break; 193 | 194 | //Cast operators 195 | case Instruction::Trunc: 196 | case Instruction::ZExt: 197 | case Instruction::SExt: 198 | case Instruction::FPTrunc: 199 | case Instruction::FPExt: 200 | latency=0.0; 201 | break; 202 | case Instruction::PtrToInt: 203 | case Instruction::IntToPtr: 204 | case Instruction::BitCast: 205 | latency=CAST_LATENCY; 206 | break; 207 | case Instruction::FPToUI: 208 | case Instruction::FPToSI: 209 | latency=FP_TO_SI; 210 | break; 211 | case Instruction::UIToFP: 212 | case Instruction::SIToFP: 213 | latency=SI_TO_FP; 214 | break; 215 | case Instruction::AddrSpaceCast: 216 | errs()<<"In AddrSpaceCast, it's not normal.\n"; 217 | break; 218 | //Other operators 219 | case Instruction::ICmp: 220 | latency=ICMP_LATENCY; 221 | break; 222 | case Instruction::FCmp: 223 | latency=FCMP_LATENCY; 224 | break; 225 | case Instruction::PHI: 226 | latency=PHI_LATENCY; 227 | break; 228 | 229 | case Instruction::Call: 230 | break; 231 | 232 | case Instruction::Select: 233 | latency=SELECT_LATENCY; 234 | break; 235 | 236 | case Instruction::UserOp1: 237 | case Instruction::UserOp2: 238 | case Instruction::VAArg: 239 | case Instruction::ExtractElement: 240 | case Instruction::InsertElement: 241 | case Instruction::ShuffleVector: 242 | case Instruction::ExtractValue: 243 | case Instruction::InsertValue: 244 | case Instruction::LandingPad: 245 | break; 246 | 247 | default: 248 | puts("It is something cannot be handled\n"); 249 | exit(0); 250 | } 251 | return latency; 252 | } 253 | -------------------------------------------------------------------------------- /test_c/utilities/polybench.R: -------------------------------------------------------------------------------- 1 | correlation <- function (M, N) { 2 | data <- matrix(0, nrow=N, ncol=M); 3 | for (i in 1:N) 4 | for (j in 1:M) 5 | data[i,j] = ((i-1)*(j-1))/M+i; 6 | 7 | cor <- cor(data); 8 | } 9 | 10 | covariance <- function (M, N) { 11 | data <- matrix(0, nrow=N, ncol=M); 12 | for (i in 1:N) 13 | for (j in 1:M) 14 | data[i,j] = ((i-1)*(j-1))/M; 15 | 16 | res <- cov(data); 17 | } 18 | 19 | gemm <- function(NI, NJ, NK) { 20 | alpha <- 1.5; 21 | beta <- 1.2; 22 | C <- matrix(0, nrow=NI, ncol=NJ); 23 | A <- matrix(0, nrow=NI, ncol=NK); 24 | B <- matrix(0, nrow=NK, ncol=NJ); 25 | 26 | for (i in 1:NI) 27 | for (j in 1:NJ) 28 | C[i,j] <- (((i-1)*(j-1)+1) %% NI) / NI; 29 | 30 | for (i in 1:NI) 31 | for (j in 1:NK) 32 | A[i,j] <- (((i-1)*j) %% NK) / NK; 33 | 34 | for (i in 1:NK) 35 | for (j in 1:NJ) 36 | B[i,j] <- (((i-1)*(j+1)) %% NJ) / NJ; 37 | 38 | res <- alpha *A %*% B + beta * C; 39 | 40 | } 41 | 42 | gemver <- function (N) { 43 | alpha <- 1.5; 44 | beta <- 1.2; 45 | A <- matrix(0, nrow=N, ncol=N); 46 | u1 <- numeric(N); 47 | u2 <- numeric(N); 48 | v1 <- numeric(N); 49 | v2 <- numeric(N); 50 | y <- numeric(N); 51 | z <- numeric(N); 52 | 53 | for (i in 1:N) { 54 | ip <- i-1; 55 | u1[i] <- ip; 56 | u2[i] <- ((ip+1)/N)/2.0; 57 | v1[i] <- ((ip+1)/N)/4.0; 58 | v2[i] <- ((ip+1)/N)/6.0; 59 | y[i] <- ((ip+1)/N)/8.0; 60 | z[i] <- ((ip+1)/N)/9.0; 61 | 62 | for (j in 1:N) { 63 | A[i,j] <- (((i-1)*(j-1)) %% N) / N; 64 | } 65 | } 66 | 67 | 68 | Aprime <- A + u1 %o% v1 + u2 %o% v2; 69 | x <- beta * t(Aprime) %*% y + z; 70 | w <- alpha * Aprime %*% x; 71 | 72 | list(Aprime, x, w); 73 | } 74 | 75 | gesummv <- function (N) { 76 | alpha <- 1.5; 77 | beta <- 1.2; 78 | A <- matrix(0, nrow=N, ncol=N); 79 | B <- matrix(0, nrow=N, ncol=N); 80 | x <- numeric(N); 81 | 82 | for (i in 1:N) { 83 | x[i] <- ((i-1) %% N) / N; 84 | 85 | for (j in 1:N) { 86 | A[i,j] <- (((i-1)*(j-1)+1) %% N) / N; 87 | B[i,j] <- (((i-1)*(j-1)+2) %% N) / N; 88 | } 89 | } 90 | 91 | y <- alpha * A %*% x + beta * B %*% x; 92 | } 93 | 94 | 95 | symm <- function(M, N) { 96 | alpha <- 1.5; 97 | beta <- 1.2; 98 | A <- matrix(0, nrow=M, ncol=M); 99 | B <- matrix(0, nrow=M, ncol=N); 100 | C <- matrix(0, nrow=M, ncol=N); 101 | 102 | for (i in 1:M) 103 | for (j in 1:N) { 104 | C[i,j] <- ((i+j-2) %% 100) / M; 105 | B[i,j] <- ((N+i-j) %% 100) / M; 106 | } 107 | for (i in 1:M) 108 | for (j in i:M) { 109 | A[i,j] <- ((i+j-2) %% 100) / M; 110 | A[j,i] <- A[i,j]; 111 | } 112 | 113 | res <- alpha * A %*% B + beta * C; 114 | 115 | } 116 | 117 | syrk <- function(M, N) { 118 | 119 | alpha <- 1.5; 120 | beta <- 1.2; 121 | A <- matrix(0, nrow=N, ncol=M); 122 | C <- matrix(0, nrow=N, ncol=N); 123 | 124 | for (i in 1:N) 125 | for (j in 1:M) 126 | A[i,j] <- (((i-1)*(j-1)+1) %% N) / N; 127 | 128 | for (i in 1:N) 129 | for (j in 1:N) 130 | C[i,j] <- (((i-1)*(j-1)+2) %% M) / M; 131 | 132 | res <- alpha * A %*% t(A) + beta * C; 133 | 134 | #note that syrk only stores lower triangular part of the resulting symmetric matrix 135 | } 136 | 137 | syr2k <- function(M, N) { 138 | 139 | alpha <- 1.5; 140 | beta <- 1.2; 141 | A <- matrix(0, nrow=N, ncol=M); 142 | B <- matrix(0, nrow=N, ncol=M); 143 | C <- matrix(0, nrow=N, ncol=N); 144 | 145 | for (i in 1:N) 146 | for (j in 1:M) { 147 | A[i,j] <- (((i-1)*(j-1)+1) %% N) / N; 148 | B[i,j] <- (((i-1)*(j-1)+2) %% M) / M; 149 | } 150 | 151 | for (i in 1:N) 152 | for (j in 1:N) 153 | C[i,j] <- (((i-1)*(j-1)+3) %% N) / M; 154 | 155 | res <- alpha * A %*% t(B) + alpha * B %*% t(A) + beta * C; 156 | 157 | } 158 | 159 | 160 | trmm <- function(M, N) { 161 | 162 | alpha <- 1.5; 163 | A <- matrix(0, nrow=M, ncol=M); 164 | B <- matrix(0, nrow=M, ncol=N); 165 | 166 | for (i in 1:M) { 167 | for (j in 1:i-1) { 168 | A[i,j] <- (((i-1)+(j-1)) %% M) / M; 169 | } 170 | A[i,i] <- 1.0; 171 | for (j in 1:N) 172 | B[i,j] <- ((N+(i-1)-(j-1)) %% N) / N; 173 | } 174 | 175 | 176 | res <- alpha * t(A) %*% B; 177 | } 178 | 179 | twomm <- function(NI, NJ, NK, NL) { 180 | alpha <- 1.5; 181 | beta <- 1.2; 182 | A <- matrix(0, nrow=NI, ncol=NK); 183 | B <- matrix(0, nrow=NK, ncol=NJ); 184 | C <- matrix(0, nrow=NJ, ncol=NL); 185 | D <- matrix(0, nrow=NI, ncol=NL); 186 | 187 | for (i in 1:NI) 188 | for (j in 1:NK) 189 | A[i,j] <- (((i-1)*(j-1)+1) %% NI) / NI; 190 | 191 | for (i in 1:NK) 192 | for (j in 1:NJ) 193 | B[i,j] <- (((i-1)*(j)) %% NJ) / NJ; 194 | 195 | for (i in 1:NJ) 196 | for (j in 1:NL) 197 | C[i,j] <- (((i-1)*(j+2)+1) %% NL) / NL; 198 | 199 | for (i in 1:NI) 200 | for (j in 1:NL) 201 | D[i,j] <- (((i-1)*(j+1)) %% NK) / NK; 202 | 203 | 204 | res <- alpha * A %*% B %*% C + beta * D; 205 | 206 | } 207 | 208 | 209 | threemm <- function(NI, NJ, NK, NL, NM) { 210 | A <- matrix(0, nrow=NI, ncol=NK); 211 | B <- matrix(0, nrow=NK, ncol=NJ); 212 | C <- matrix(0, nrow=NJ, ncol=NM); 213 | D <- matrix(0, nrow=NM, ncol=NL); 214 | 215 | for (i in 1:NI) 216 | for (j in 1:NK) 217 | A[i,j] <- (((i-1)*(j-1)+1) %% NI) / (5*NI); 218 | 219 | for (i in 1:NK) 220 | for (j in 1:NJ) 221 | B[i,j] <- (((i-1)*(j)+2) %% NJ) / (5*NJ); 222 | 223 | for (i in 1:NJ) 224 | for (j in 1:NM) 225 | C[i,j] <- (((i-1)*(j+2)) %% NL) / (5*NL); 226 | 227 | for (i in 1:NM) 228 | for (j in 1:NL) 229 | D[i,j] <- (((i-1)*(j+1)+2) %% NK) / (5*NK); 230 | 231 | 232 | E <- A %*% B; 233 | F <- C %*% D; 234 | G <- E %*% F; 235 | 236 | } 237 | 238 | atax <- function(M, N) { 239 | A <- matrix(0, nrow=M, ncol=N); 240 | x <- numeric(N); 241 | 242 | for (i in 1:N) 243 | x[i] <- 1 + ((i-1) / N); 244 | 245 | for (i in 1:M) 246 | for (j in 1:N) 247 | A[i,j] <- (((i-1)+(j-1)) %% N) / (5*M) 248 | 249 | 250 | y <- t(A) %*% (A %*% x); 251 | 252 | } 253 | 254 | mvt <- function(N) { 255 | x1 <- numeric(N); 256 | x2 <- numeric(N); 257 | y1 <- numeric(N); 258 | y2 <- numeric(N); 259 | A <- matrix(0, nrow=N, ncol=N); 260 | 261 | for (i in 1:N) { 262 | ip <- i-1; 263 | x1[i] <- (ip %% N) / N; 264 | x2[i] <- ((ip + 1) %% N) / N; 265 | y1[i] <- ((ip + 3) %% N) / N; 266 | y2[i] <- ((ip + 4) %% N) / N; 267 | for (j in 1:N) 268 | A[i,j] <- (((i-1)*(j-1)) %% N) / N; 269 | } 270 | 271 | 272 | x1 <- x1 + A %*% y1; 273 | x2 <- x2 + t(A) %*% y2; 274 | } 275 | 276 | cholesky <- function(N) { 277 | A <- matrix(0, nrow=N, ncol=N) 278 | 279 | for (i in 1:N) { 280 | for (j in 1:i) 281 | A[i,j] <- ((-((j-1) %% N)) / N) + 1 282 | A[i,i] <- 1; 283 | } 284 | 285 | A <- A %*% t(A); 286 | 287 | res <- chol(A); 288 | } 289 | 290 | durbin <- function(N) { 291 | r <- numeric(N+1) 292 | 293 | r[1] = 1; 294 | for (i in 2:(N+1)) 295 | r[i] <- N+1-(i-2) 296 | 297 | r1 <- r[1:N] 298 | r2 <- r[2:(N+1)] 299 | 300 | res <- solve(toeplitz(r1), -r2) 301 | } 302 | 303 | gramschmidt <- function(M, N) { 304 | A <- matrix(0, nrow=M, ncol=N); 305 | 306 | for (i in 1:M) 307 | for (j in 1:N) 308 | A[i,j] <- ((((i-1)*(j-1)) %% M) / M)*100 + 10 309 | 310 | res <- qr(A); 311 | 312 | list(res, qr.Q(res), qr.R(res)) 313 | } 314 | 315 | library('Matrix') 316 | lu.polybench <- function(N) { 317 | A <- matrix(0, nrow=N, ncol=N) 318 | 319 | 320 | for (i in 1:N) { 321 | for (j in 1:i) 322 | A[i,j] <- ((-((j-1) %% N)) / N) + 1 323 | A[i,i] <- 1; 324 | } 325 | 326 | A <- A %*% t(A); 327 | 328 | res <- expand(lu(A)); 329 | } 330 | 331 | ludcmp <- function(N) { 332 | b <- numeric(N); 333 | for (i in 1:N) 334 | b[i] <- ((i/N)/2.0) +4; 335 | 336 | A <- matrix(0, nrow=N, ncol=N) 337 | 338 | for (i in 1:N) { 339 | for (j in 1:i) 340 | A[i,j] <- ((-((j-1) %% N)) / N) + 1 341 | A[i,i] <- 1; 342 | } 343 | 344 | A <- A %*% t(A); 345 | 346 | res <- solve(A, b); 347 | } 348 | 349 | trisolv <- function(N) { 350 | L <- matrix(0, nrow=N, ncol=N) 351 | b <- c(0:(N-1)) 352 | 353 | for (i in 1:N) 354 | for (j in 0:i) 355 | L[i,j] <- (((i-1)+N-(j-1)+1)*2) / N 356 | 357 | res <- solve(L, b) 358 | } 359 | -------------------------------------------------------------------------------- /src/UpdateMem.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * COMBA 3 | * Copyright (C) 2017 RCSL, HKUST 4 | * 5 | * ONLY FOR ACADEMIC USE, NOT FOR COMMERCIAL USE. 6 | * 7 | * Please use our tool at academic institutions and non-profit 8 | * research organizations for research use. 9 | * 10 | * 11 | */ 12 | 13 | 14 | #include "UpdateMem.h" 15 | #include "MemOpNum.h" 16 | #include "Constant.h" 17 | #include "EvaluateDependency.h" 18 | 19 | 20 | void complete_load_update(Loop *L1, Loop *L2, float latency,float latency_delta, unsigned index1,unsigned index2, Instruction* inst,std::vector > *dependence_loop) 21 | { 22 | if(L1==NULL){ 23 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 24 | Loop *parent=L2->getParentLoop(); 25 | if(parent==NULL){ 26 | dependence_loop[index1].push_back(std::make_pair(index2,latency_delta)); 27 | Load_latency[inst]=latency_delta; 28 | } 29 | else{ 30 | if(Loops_unroll[parent]>=Loops_counter[parent]){ 31 | complete_load_update(L1,parent,latency,latency_delta,index1,index2,inst,dependence_loop); 32 | } 33 | else{ 34 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 35 | Load_latency[inst]=latency; 36 | } 37 | } 38 | } 39 | else{ 40 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 41 | Load_latency[inst]=latency; 42 | } 43 | } 44 | else{ 45 | if(L1->contains(L2)){ 46 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 47 | Loop *parent=L2->getParentLoop(); 48 | if(L1==parent){ 49 | dependence_loop[index1].push_back(std::make_pair(index2,latency_delta)); 50 | Load_latency[inst]=latency_delta; 51 | } 52 | else{ 53 | complete_load_update(L1,parent,latency,latency_delta,index1,index2,inst,dependence_loop); 54 | } 55 | } 56 | else{ 57 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 58 | Load_latency[inst]=latency; 59 | } 60 | } 61 | else if(L2->contains(L1)){ 62 | if(Loops_unroll[L1]>=Loops_counter[L1]){ 63 | Loop *parent=L1->getParentLoop(); 64 | if(L2==parent){ 65 | dependence_loop[index1].push_back(std::make_pair(index2,latency_delta)); 66 | Load_latency[inst]=latency_delta; 67 | } 68 | else{ 69 | complete_load_update(parent,L2,latency,latency_delta,index1,index2,inst,dependence_loop); 70 | } 71 | } 72 | else{ 73 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 74 | Load_latency[inst]=latency; 75 | } 76 | } 77 | else if(L1==L2){ 78 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 79 | Load_latency[inst]=latency; 80 | } 81 | else{ 82 | Loop *parent2=L2->getParentLoop(); 83 | Loop *parent1=L1->getParentLoop(); 84 | if(parent1==parent2){ 85 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 86 | if(Loops_unroll[L1]>=Loops_unroll[L1]){ 87 | dependence_loop[index1].push_back(std::make_pair(index2,latency_delta)); 88 | Load_latency[inst]=latency_delta; 89 | } 90 | else{ 91 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 92 | Load_latency[inst]=latency; 93 | } 94 | } 95 | else{ 96 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 97 | Load_latency[inst]=latency; 98 | } 99 | } 100 | else{ 101 | if(parent2==NULL){ 102 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 103 | dependence_loop[index1].push_back(std::make_pair(index2,latency_delta)); 104 | Load_latency[inst]=latency_delta; 105 | } 106 | else{ 107 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 108 | Load_latency[inst]=latency; 109 | } 110 | } 111 | else{ 112 | if(parent2->contains(L1)){ 113 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 114 | dependence_loop[index1].push_back(std::make_pair(index2,latency_delta)); 115 | Load_latency[inst]=latency_delta; 116 | } 117 | else{ 118 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 119 | Load_latency[inst]=latency; 120 | } 121 | } 122 | else{ 123 | if(Loops_unroll[parent2]>=Loops_counter[parent2]){ 124 | complete_load_update(L1,parent2,latency,latency_delta,index1,index2,inst,dependence_loop); 125 | } 126 | else{ 127 | dependence_loop[index1].push_back(std::make_pair(index2,latency)); 128 | Load_latency[inst]=latency; 129 | } 130 | } 131 | } 132 | } 133 | } 134 | } 135 | } 136 | 137 | 138 | void update_load(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop) 139 | { 140 | unsigned index_inst=0; 141 | index_inst=instr_index_loop[inst]; 142 | BasicBlock *bb1=inst->getParent(); 143 | Loop *L1=LI->getLoopFor(bb1); 144 | float latency=Load_latency[inst]; 145 | std::map::iterator it; 146 | for(it=instr_index_loop.begin();it!=instr_index_loop.end();++it){ 147 | Instruction *inst_tmp=it->first; 148 | unsigned index_inst_tmp=it->second; 149 | if(isa(inst_tmp)){ 150 | BasicBlock *bb2=inst_tmp->getParent(); 151 | if(bb1!=bb2){ 152 | bool LS_dependency=load_store_dependency(inst,inst_tmp); 153 | if(LS_dependency==true){ 154 | std::vector< std::pair >::iterator i= dependence_loop[index_inst].begin(); 155 | if(i->first==(int)index_inst){ 156 | i->second=0; 157 | } 158 | Loop *L2=LI->getLoopFor(bb2); 159 | if(L1==L2){ 160 | dependence_loop[index_inst_tmp].push_back(std::make_pair(index_inst,latency)); 161 | Load_latency[inst]=latency; 162 | } 163 | else{ 164 | int load_num=compute_total_LS_num(LI,inst); 165 | int store_num=compute_total_LS_num(LI,inst_tmp); 166 | int delta=load_num-store_num; 167 | if(delta<0){ 168 | delta=0; 169 | } 170 | float latency_delta=ceil((float)delta/(float)port_num_read); 171 | if(L2==NULL){ 172 | dependence_loop[index_inst_tmp].push_back(std::make_pair(index_inst,latency_delta)); 173 | Load_latency[inst]=latency_delta; 174 | } 175 | else{ 176 | complete_load_update(L1,L2,latency,latency_delta,index_inst_tmp,index_inst,inst,dependence_loop); 177 | } 178 | } 179 | } 180 | } 181 | } 182 | } 183 | } 184 | 185 | 186 | void replace_write_latency(int store_num1, int store_num2, unsigned index, Instruction *inst,std::vector > *dependence_loop) 187 | { 188 | float latency=ceil((float)store_num1/(float)port_num_write_diff); 189 | if(store_num2<=store_num1){ 190 | for(std::vector >::iterator i=dependence_loop[index].begin();i!=dependence_loop[index].end();++i){ 191 | if(i->first==(int)index){ 192 | i->second=0.0; 193 | } 194 | } 195 | Store_latency[inst]=0.0; 196 | } 197 | else{ 198 | for(std::vector >::iterator i=dependence_loop[index].begin();i!=dependence_loop[index].end();++i){ 199 | if(i->first==(int)index){ 200 | if(i->secondsecond=0.0; 202 | Store_latency[inst]=0.0; 203 | } 204 | else{ 205 | i->second=i->second-latency; 206 | Store_latency[inst]=i->second; 207 | } 208 | } 209 | } 210 | } 211 | } 212 | 213 | 214 | void complete_store_update(Loop *L1, Loop *L2, int store_num1, int store_num2, unsigned index, Instruction *inst, std::vector > *dependence_loop) 215 | { 216 | if(L1!=L2){ 217 | if(L1==NULL){ 218 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 219 | Loop *parent = L2->getParentLoop(); 220 | if(parent==NULL){ 221 | replace_write_latency(store_num1,store_num2,index,inst,dependence_loop); 222 | } 223 | else{ 224 | complete_store_update(L1,parent,store_num1,store_num2,index,inst,dependence_loop); 225 | } 226 | } 227 | } 228 | else{ 229 | if(L1->contains(L2)){ 230 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 231 | Loop *parent=L2->getParentLoop(); 232 | if(L1==parent){ 233 | replace_write_latency(store_num1,store_num2,index,inst,dependence_loop); 234 | } 235 | else{ 236 | complete_store_update(L1,parent,store_num1,store_num2,index,inst,dependence_loop); 237 | } 238 | } 239 | } 240 | else if(L2->contains(L1)){ 241 | if(Loops_unroll[L1]>=Loops_counter[L1]){ 242 | Loop *parent=L1->getParentLoop(); 243 | if(L2==parent){ 244 | replace_write_latency(store_num1,store_num2,index,inst,dependence_loop); 245 | } 246 | else{ 247 | complete_store_update(parent,L2,store_num1,store_num2,index,inst,dependence_loop); 248 | } 249 | } 250 | } 251 | else{ 252 | Loop *parent2=L2->getParentLoop(); 253 | Loop *parent1=L1->getParentLoop(); 254 | if(parent1==parent2){ 255 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 256 | if(Loops_unroll[L1]>=Loops_unroll[L1]){ 257 | replace_write_latency(store_num1,store_num2,index,inst,dependence_loop); 258 | } 259 | } 260 | } 261 | else{ 262 | if(parent2==NULL){ 263 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 264 | replace_write_latency(store_num1,store_num2,index,inst,dependence_loop); 265 | } 266 | } 267 | else{ 268 | if(parent2->contains(L1)){ 269 | if(Loops_unroll[L2]>=Loops_counter[L2]){ 270 | replace_write_latency(store_num1,store_num2,index,inst,dependence_loop); 271 | } 272 | } 273 | else{ 274 | if(Loops_unroll[parent2]>=Loops_counter[parent2]){ 275 | complete_store_update(L1,parent2,store_num1,store_num2,index,inst,dependence_loop); 276 | } 277 | } 278 | } 279 | } 280 | } 281 | } 282 | } 283 | } 284 | 285 | void update_store(LoopInfo* LI, Instruction *inst, std::map &instr_index_loop, std::vector > *dependence_loop) 286 | { 287 | BasicBlock *bb1=inst->getParent(); 288 | Loop *L1=LI->getLoopFor(bb1); 289 | std::map::iterator it; 290 | for(it=instr_index_loop.begin();it!=instr_index_loop.end();++it){ 291 | Instruction *inst_tmp=it->first; 292 | unsigned index_inst_tmp=it->second; 293 | if(isa(inst_tmp)){ 294 | if(inst_tmp!=inst){ 295 | BasicBlock *bb2=inst_tmp->getParent(); 296 | if(bb1!=bb2){ 297 | bool SS_dependency=store_store_dependency(inst,inst_tmp); 298 | if(SS_dependency==true){ 299 | //dependence_loop[index_inst_tmp].push_back(std::make_pair(index_inst,0.0)); 300 | Loop *L2=LI->getLoopFor(bb2); 301 | if(L1!=L2){ 302 | int store_num1=compute_total_LS_num(LI,inst); 303 | int store_num2=compute_total_LS_num(LI,inst_tmp); 304 | if(L2==NULL){ 305 | if(Loops_unroll[L1]>=Loops_counter[L1]){ 306 | replace_write_latency(store_num1,store_num2,index_inst_tmp,inst_tmp,dependence_loop); 307 | } 308 | } 309 | else{ 310 | complete_store_update(L1,L2,store_num1,store_num2,index_inst_tmp,inst_tmp,dependence_loop); 311 | } 312 | } 313 | } 314 | } 315 | } 316 | } 317 | } 318 | } 319 | -------------------------------------------------------------------------------- /src/Release+Asserts/GEP.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/GEP.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/GEP.d: \ 3 | GEP.cpp GEP.h test.h /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 4 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h \ 5 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h \ 6 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h \ 7 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 8 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h \ 9 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h \ 10 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h \ 11 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h \ 12 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h \ 13 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h \ 14 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h \ 15 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h \ 16 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h \ 17 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h \ 18 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h \ 19 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h \ 20 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h \ 21 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h \ 22 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h \ 23 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h \ 24 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h \ 25 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h \ 26 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h \ 27 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h \ 28 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h \ 29 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h \ 30 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h \ 31 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h \ 32 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h \ 33 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h \ 34 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h \ 35 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h \ 36 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h \ 37 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h \ 38 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h \ 39 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h \ 40 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h \ 41 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def \ 42 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h \ 43 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h \ 44 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h \ 45 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h \ 46 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h \ 47 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h \ 48 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h \ 49 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h \ 50 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h \ 51 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h \ 52 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h \ 53 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h \ 54 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h \ 55 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h \ 56 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h \ 57 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h \ 58 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h \ 59 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h \ 60 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h \ 61 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h \ 62 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h \ 63 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h \ 64 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h \ 65 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen \ 66 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h \ 67 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h \ 68 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h \ 69 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h \ 70 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h \ 71 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h \ 72 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h \ 73 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h \ 74 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h \ 75 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h \ 76 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h \ 77 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h \ 78 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h \ 79 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h \ 80 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h \ 81 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h \ 82 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h \ 83 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h \ 84 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h 85 | 86 | GEP.h: 87 | 88 | test.h: 89 | 90 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 91 | 92 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h: 93 | 94 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h: 95 | 96 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h: 97 | 98 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 99 | 100 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h: 101 | 102 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h: 103 | 104 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h: 105 | 106 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h: 107 | 108 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h: 109 | 110 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h: 111 | 112 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h: 113 | 114 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h: 115 | 116 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h: 117 | 118 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h: 119 | 120 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h: 121 | 122 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h: 123 | 124 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h: 125 | 126 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h: 127 | 128 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h: 129 | 130 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h: 131 | 132 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h: 133 | 134 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h: 135 | 136 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h: 137 | 138 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h: 139 | 140 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h: 141 | 142 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h: 143 | 144 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h: 145 | 146 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h: 147 | 148 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h: 149 | 150 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h: 151 | 152 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h: 153 | 154 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h: 155 | 156 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h: 157 | 158 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h: 159 | 160 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h: 161 | 162 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h: 163 | 164 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h: 165 | 166 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def: 167 | 168 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h: 169 | 170 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h: 171 | 172 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h: 173 | 174 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h: 175 | 176 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h: 177 | 178 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h: 179 | 180 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h: 181 | 182 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h: 183 | 184 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h: 185 | 186 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h: 187 | 188 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h: 189 | 190 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h: 191 | 192 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h: 193 | 194 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h: 195 | 196 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h: 197 | 198 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h: 199 | 200 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h: 201 | 202 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h: 203 | 204 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h: 205 | 206 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h: 207 | 208 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h: 209 | 210 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h: 211 | 212 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h: 213 | 214 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen: 215 | 216 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h: 217 | 218 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h: 219 | 220 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h: 221 | 222 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h: 223 | 224 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h: 225 | 226 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h: 227 | 228 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h: 229 | 230 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h: 231 | 232 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h: 233 | 234 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h: 235 | 236 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h: 237 | 238 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h: 239 | 240 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h: 241 | 242 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h: 243 | 244 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h: 245 | 246 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h: 247 | 248 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h: 249 | 250 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h: 251 | 252 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h: 253 | -------------------------------------------------------------------------------- /src/Release+Asserts/Cast.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/Cast.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/Cast.d: \ 3 | Cast.cpp Cast.h test.h /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 4 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h \ 5 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h \ 6 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h \ 7 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 8 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h \ 9 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h \ 10 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h \ 11 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h \ 12 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h \ 13 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h \ 14 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h \ 15 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h \ 16 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h \ 17 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h \ 18 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h \ 19 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h \ 20 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h \ 21 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h \ 22 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h \ 23 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h \ 24 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h \ 25 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h \ 26 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h \ 27 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h \ 28 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h \ 29 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h \ 30 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h \ 31 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h \ 32 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h \ 33 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h \ 34 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h \ 35 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h \ 36 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h \ 37 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h \ 38 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h \ 39 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h \ 40 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h \ 41 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def \ 42 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h \ 43 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h \ 44 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h \ 45 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h \ 46 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h \ 47 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h \ 48 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h \ 49 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h \ 50 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h \ 51 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h \ 52 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h \ 53 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h \ 54 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h \ 55 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h \ 56 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h \ 57 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h \ 58 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h \ 59 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h \ 60 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h \ 61 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h \ 62 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h \ 63 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h \ 64 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h \ 65 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen \ 66 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h \ 67 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h \ 68 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h \ 69 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h \ 70 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h \ 71 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h \ 72 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h \ 73 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h \ 74 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h \ 75 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h \ 76 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h \ 77 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h \ 78 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h \ 79 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h \ 80 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h \ 81 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h \ 82 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h \ 83 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h \ 84 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h 85 | 86 | Cast.h: 87 | 88 | test.h: 89 | 90 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 91 | 92 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h: 93 | 94 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h: 95 | 96 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h: 97 | 98 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 99 | 100 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h: 101 | 102 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h: 103 | 104 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h: 105 | 106 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h: 107 | 108 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h: 109 | 110 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h: 111 | 112 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h: 113 | 114 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h: 115 | 116 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h: 117 | 118 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h: 119 | 120 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h: 121 | 122 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h: 123 | 124 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h: 125 | 126 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h: 127 | 128 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h: 129 | 130 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h: 131 | 132 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h: 133 | 134 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h: 135 | 136 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h: 137 | 138 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h: 139 | 140 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h: 141 | 142 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h: 143 | 144 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h: 145 | 146 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h: 147 | 148 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h: 149 | 150 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h: 151 | 152 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h: 153 | 154 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h: 155 | 156 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h: 157 | 158 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h: 159 | 160 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h: 161 | 162 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h: 163 | 164 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h: 165 | 166 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def: 167 | 168 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h: 169 | 170 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h: 171 | 172 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h: 173 | 174 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h: 175 | 176 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h: 177 | 178 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h: 179 | 180 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h: 181 | 182 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h: 183 | 184 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h: 185 | 186 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h: 187 | 188 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h: 189 | 190 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h: 191 | 192 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h: 193 | 194 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h: 195 | 196 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h: 197 | 198 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h: 199 | 200 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h: 201 | 202 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h: 203 | 204 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h: 205 | 206 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h: 207 | 208 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h: 209 | 210 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h: 211 | 212 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h: 213 | 214 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen: 215 | 216 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h: 217 | 218 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h: 219 | 220 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h: 221 | 222 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h: 223 | 224 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h: 225 | 226 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h: 227 | 228 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h: 229 | 230 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h: 231 | 232 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h: 233 | 234 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h: 235 | 236 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h: 237 | 238 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h: 239 | 240 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h: 241 | 242 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h: 243 | 244 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h: 245 | 246 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h: 247 | 248 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h: 249 | 250 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h: 251 | 252 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h: 253 | -------------------------------------------------------------------------------- /src/Release+Asserts/ArrayName.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/ArrayName.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/ArrayName.d: \ 3 | ArrayName.cpp ArrayName.h test.h \ 4 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 5 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h \ 6 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h \ 7 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h \ 8 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 9 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h \ 10 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h \ 11 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h \ 12 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h \ 13 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h \ 14 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h \ 15 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h \ 16 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h \ 17 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h \ 18 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h \ 19 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h \ 20 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h \ 21 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h \ 22 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h \ 23 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h \ 24 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h \ 25 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h \ 26 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h \ 27 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h \ 28 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h \ 29 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h \ 30 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h \ 31 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h \ 32 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h \ 33 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h \ 34 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h \ 35 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h \ 36 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h \ 37 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h \ 38 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h \ 39 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h \ 40 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h \ 41 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h \ 42 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def \ 43 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h \ 44 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h \ 45 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h \ 46 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h \ 47 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h \ 48 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h \ 49 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h \ 50 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h \ 51 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h \ 52 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h \ 53 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h \ 54 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h \ 55 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h \ 56 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h \ 57 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h \ 58 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h \ 59 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h \ 60 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h \ 61 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h \ 62 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h \ 63 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h \ 64 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h \ 65 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h \ 66 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen \ 67 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h \ 68 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h \ 69 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h \ 70 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h \ 71 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h \ 72 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h \ 73 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h \ 74 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h \ 75 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h \ 76 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h \ 77 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h \ 78 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h \ 79 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h \ 80 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h \ 81 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h \ 82 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h \ 83 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h \ 84 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h \ 85 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h 86 | 87 | ArrayName.h: 88 | 89 | test.h: 90 | 91 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 92 | 93 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h: 94 | 95 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h: 96 | 97 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h: 98 | 99 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 100 | 101 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h: 102 | 103 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h: 104 | 105 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h: 106 | 107 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h: 108 | 109 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h: 110 | 111 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h: 112 | 113 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h: 114 | 115 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h: 116 | 117 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h: 118 | 119 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h: 120 | 121 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h: 122 | 123 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h: 124 | 125 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h: 126 | 127 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h: 128 | 129 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h: 130 | 131 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h: 132 | 133 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h: 134 | 135 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h: 136 | 137 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h: 138 | 139 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h: 140 | 141 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h: 142 | 143 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h: 144 | 145 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h: 146 | 147 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h: 148 | 149 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h: 150 | 151 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h: 152 | 153 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h: 154 | 155 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h: 156 | 157 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h: 158 | 159 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h: 160 | 161 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h: 162 | 163 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h: 164 | 165 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h: 166 | 167 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def: 168 | 169 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h: 170 | 171 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h: 172 | 173 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h: 174 | 175 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h: 176 | 177 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h: 178 | 179 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h: 180 | 181 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h: 182 | 183 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h: 184 | 185 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h: 186 | 187 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h: 188 | 189 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h: 190 | 191 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h: 192 | 193 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h: 194 | 195 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h: 196 | 197 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h: 198 | 199 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h: 200 | 201 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h: 202 | 203 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h: 204 | 205 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h: 206 | 207 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h: 208 | 209 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h: 210 | 211 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h: 212 | 213 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h: 214 | 215 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen: 216 | 217 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h: 218 | 219 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h: 220 | 221 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h: 222 | 223 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h: 224 | 225 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h: 226 | 227 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h: 228 | 229 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h: 230 | 231 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h: 232 | 233 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h: 234 | 235 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h: 236 | 237 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h: 238 | 239 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h: 240 | 241 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h: 242 | 243 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h: 244 | 245 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h: 246 | 247 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h: 248 | 249 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h: 250 | 251 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h: 252 | 253 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h: 254 | -------------------------------------------------------------------------------- /src/Release+Asserts/LoopDepth.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/LoopDepth.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/LoopDepth.d: \ 3 | LoopDepth.cpp LoopDepth.h test.h \ 4 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 5 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h \ 6 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h \ 7 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h \ 8 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 9 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h \ 10 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h \ 11 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h \ 12 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h \ 13 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h \ 14 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h \ 15 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h \ 16 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h \ 17 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h \ 18 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h \ 19 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h \ 20 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h \ 21 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h \ 22 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h \ 23 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h \ 24 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h \ 25 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h \ 26 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h \ 27 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h \ 28 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h \ 29 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h \ 30 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h \ 31 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h \ 32 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h \ 33 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h \ 34 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h \ 35 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h \ 36 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h \ 37 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h \ 38 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h \ 39 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h \ 40 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h \ 41 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h \ 42 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def \ 43 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h \ 44 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h \ 45 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h \ 46 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h \ 47 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h \ 48 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h \ 49 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h \ 50 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h \ 51 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h \ 52 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h \ 53 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h \ 54 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h \ 55 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h \ 56 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h \ 57 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h \ 58 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h \ 59 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h \ 60 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h \ 61 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h \ 62 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h \ 63 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h \ 64 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h \ 65 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h \ 66 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen \ 67 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h \ 68 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h \ 69 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h \ 70 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h \ 71 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h \ 72 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h \ 73 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h \ 74 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h \ 75 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h \ 76 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h \ 77 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h \ 78 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h \ 79 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h \ 80 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h \ 81 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h \ 82 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h \ 83 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h \ 84 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h \ 85 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h 86 | 87 | LoopDepth.h: 88 | 89 | test.h: 90 | 91 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 92 | 93 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h: 94 | 95 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h: 96 | 97 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h: 98 | 99 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 100 | 101 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h: 102 | 103 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h: 104 | 105 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h: 106 | 107 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h: 108 | 109 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h: 110 | 111 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h: 112 | 113 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h: 114 | 115 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h: 116 | 117 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h: 118 | 119 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h: 120 | 121 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h: 122 | 123 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h: 124 | 125 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h: 126 | 127 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h: 128 | 129 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h: 130 | 131 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h: 132 | 133 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h: 134 | 135 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h: 136 | 137 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h: 138 | 139 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h: 140 | 141 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h: 142 | 143 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h: 144 | 145 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h: 146 | 147 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h: 148 | 149 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h: 150 | 151 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h: 152 | 153 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h: 154 | 155 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h: 156 | 157 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h: 158 | 159 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h: 160 | 161 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h: 162 | 163 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h: 164 | 165 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h: 166 | 167 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def: 168 | 169 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h: 170 | 171 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h: 172 | 173 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h: 174 | 175 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h: 176 | 177 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h: 178 | 179 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h: 180 | 181 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h: 182 | 183 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h: 184 | 185 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h: 186 | 187 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h: 188 | 189 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h: 190 | 191 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h: 192 | 193 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h: 194 | 195 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h: 196 | 197 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h: 198 | 199 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h: 200 | 201 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h: 202 | 203 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h: 204 | 205 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h: 206 | 207 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h: 208 | 209 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h: 210 | 211 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h: 212 | 213 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h: 214 | 215 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen: 216 | 217 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h: 218 | 219 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h: 220 | 221 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h: 222 | 223 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h: 224 | 225 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h: 226 | 227 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h: 228 | 229 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h: 230 | 231 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h: 232 | 233 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h: 234 | 235 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h: 236 | 237 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h: 238 | 239 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h: 240 | 241 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h: 242 | 243 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h: 244 | 245 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h: 246 | 247 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h: 248 | 249 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h: 250 | 251 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h: 252 | 253 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h: 254 | -------------------------------------------------------------------------------- /src/Release+Asserts/SetPragma.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/SetPragma.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/SetPragma.d: \ 3 | SetPragma.cpp SetPragma.h test.h \ 4 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 5 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h \ 6 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h \ 7 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h \ 8 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 9 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h \ 10 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h \ 11 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h \ 12 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h \ 13 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h \ 14 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h \ 15 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h \ 16 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h \ 17 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h \ 18 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h \ 19 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h \ 20 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h \ 21 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h \ 22 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h \ 23 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h \ 24 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h \ 25 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h \ 26 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h \ 27 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h \ 28 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h \ 29 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h \ 30 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h \ 31 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h \ 32 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h \ 33 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h \ 34 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h \ 35 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h \ 36 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h \ 37 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h \ 38 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h \ 39 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h \ 40 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h \ 41 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h \ 42 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def \ 43 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h \ 44 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h \ 45 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h \ 46 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h \ 47 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h \ 48 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h \ 49 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h \ 50 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h \ 51 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h \ 52 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h \ 53 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h \ 54 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h \ 55 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h \ 56 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h \ 57 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h \ 58 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h \ 59 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h \ 60 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h \ 61 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h \ 62 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h \ 63 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h \ 64 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h \ 65 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h \ 66 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen \ 67 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h \ 68 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h \ 69 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h \ 70 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h \ 71 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h \ 72 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h \ 73 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h \ 74 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h \ 75 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h \ 76 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h \ 77 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h \ 78 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h \ 79 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h \ 80 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h \ 81 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h \ 82 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h \ 83 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h \ 84 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h \ 85 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h 86 | 87 | SetPragma.h: 88 | 89 | test.h: 90 | 91 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 92 | 93 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h: 94 | 95 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h: 96 | 97 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h: 98 | 99 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 100 | 101 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h: 102 | 103 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h: 104 | 105 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h: 106 | 107 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h: 108 | 109 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h: 110 | 111 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h: 112 | 113 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h: 114 | 115 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h: 116 | 117 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h: 118 | 119 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h: 120 | 121 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h: 122 | 123 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h: 124 | 125 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h: 126 | 127 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h: 128 | 129 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h: 130 | 131 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h: 132 | 133 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h: 134 | 135 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h: 136 | 137 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h: 138 | 139 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h: 140 | 141 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h: 142 | 143 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h: 144 | 145 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h: 146 | 147 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h: 148 | 149 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h: 150 | 151 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h: 152 | 153 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h: 154 | 155 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h: 156 | 157 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h: 158 | 159 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h: 160 | 161 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h: 162 | 163 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h: 164 | 165 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h: 166 | 167 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def: 168 | 169 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h: 170 | 171 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h: 172 | 173 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h: 174 | 175 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h: 176 | 177 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h: 178 | 179 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h: 180 | 181 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h: 182 | 183 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h: 184 | 185 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h: 186 | 187 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h: 188 | 189 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h: 190 | 191 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h: 192 | 193 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h: 194 | 195 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h: 196 | 197 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h: 198 | 199 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h: 200 | 201 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h: 202 | 203 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h: 204 | 205 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h: 206 | 207 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h: 208 | 209 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h: 210 | 211 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h: 212 | 213 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h: 214 | 215 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen: 216 | 217 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h: 218 | 219 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h: 220 | 221 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h: 222 | 223 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h: 224 | 225 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h: 226 | 227 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h: 228 | 229 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h: 230 | 231 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h: 232 | 233 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h: 234 | 235 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h: 236 | 237 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h: 238 | 239 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h: 240 | 241 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h: 242 | 243 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h: 244 | 245 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h: 246 | 247 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h: 248 | 249 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h: 250 | 251 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h: 252 | 253 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h: 254 | -------------------------------------------------------------------------------- /src/Release+Asserts/ComputeFixedPath.d: -------------------------------------------------------------------------------- 1 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/ComputeFixedPath.o \ 2 | /home/zjr/HLSModel/llvm-3.4/lib/Transforms/Comba/src/Release+Asserts/ComputeFixedPath.d: \ 3 | ComputeFixedPath.cpp ComputeFixedPath.h test.h \ 4 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 5 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h \ 6 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h \ 7 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h \ 8 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h \ 9 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h \ 10 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h \ 11 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h \ 12 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h \ 13 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h \ 14 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h \ 15 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h \ 16 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h \ 17 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h \ 18 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h \ 19 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h \ 20 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h \ 21 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h \ 22 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h \ 23 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h \ 24 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h \ 25 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h \ 26 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h \ 27 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h \ 28 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h \ 29 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h \ 30 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h \ 31 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h \ 32 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h \ 33 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h \ 34 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h \ 35 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h \ 36 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h \ 37 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h \ 38 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h \ 39 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h \ 40 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h \ 41 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h \ 42 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def \ 43 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h \ 44 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h \ 45 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h \ 46 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h \ 47 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h \ 48 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h \ 49 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h \ 50 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h \ 51 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h \ 52 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h \ 53 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h \ 54 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h \ 55 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h \ 56 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h \ 57 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h \ 58 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h \ 59 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h \ 60 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h \ 61 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h \ 62 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h \ 63 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h \ 64 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h \ 65 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h \ 66 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen \ 67 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h \ 68 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h \ 69 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h \ 70 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h \ 71 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h \ 72 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h \ 73 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h \ 74 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h \ 75 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h \ 76 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h \ 77 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h \ 78 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h \ 79 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h \ 80 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h \ 81 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h \ 82 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h \ 83 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h \ 84 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h \ 85 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h 86 | 87 | ComputeFixedPath.h: 88 | 89 | test.h: 90 | 91 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 92 | 93 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Compiler.h: 94 | 95 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Config/llvm-config.h: 96 | 97 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassSupport.h: 98 | 99 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Pass.h: 100 | 101 | /home/zjr/HLSModel/llvm-3.4/include/llvm/InitializePasses.h: 102 | 103 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassRegistry.h: 104 | 105 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/StringRef.h: 106 | 107 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/type_traits.h: 108 | 109 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DataTypes.h: 110 | 111 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CBindingWrapping.h: 112 | 113 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Casting.h: 114 | 115 | /home/zjr/HLSModel/llvm-3.4/include/llvm-c/Core.h: 116 | 117 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Atomic.h: 118 | 119 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Valgrind.h: 120 | 121 | /home/zjr/HLSModel/llvm-3.4/include/llvm/PassAnalysisSupport.h: 122 | 123 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallVector.h: 124 | 125 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/AlignOf.h: 126 | 127 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/MathExtras.h: 128 | 129 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SwapByteOrder.h: 130 | 131 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Function.h: 132 | 133 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Argument.h: 134 | 135 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Twine.h: 136 | 137 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/ErrorHandling.h: 138 | 139 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist_node.h: 140 | 141 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Attributes.h: 142 | 143 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ArrayRef.h: 144 | 145 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/None.h: 146 | 147 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/FoldingSet.h: 148 | 149 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/PointerLikeTypeTraits.h: 150 | 151 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Value.h: 152 | 153 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Use.h: 154 | 155 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/PointerIntPair.h: 156 | 157 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/BasicBlock.h: 158 | 159 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/ilist.h: 160 | 161 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.h: 162 | 163 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/User.h: 164 | 165 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DebugLoc.h: 166 | 167 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instruction.def: 168 | 169 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/SymbolTableListTraits.h: 170 | 171 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/CallingConv.h: 172 | 173 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalValue.h: 174 | 175 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constant.h: 176 | 177 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/DerivedTypes.h: 178 | 179 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Type.h: 180 | 181 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APFloat.h: 182 | 183 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/APInt.h: 184 | 185 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/raw_ostream.h: 186 | 187 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/FileSystem.h: 188 | 189 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/IntrusiveRefCntPtr.h: 190 | 191 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/OwningPtr.h: 192 | 193 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallString.h: 194 | 195 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/TimeValue.h: 196 | 197 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/system_error.h: 198 | 199 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/CFG.h: 200 | 201 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/GraphTraits.h: 202 | 203 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/InstrTypes.h: 204 | 205 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/OperandTraits.h: 206 | 207 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/GraphWriter.h: 208 | 209 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/DOTGraphTraits.h: 210 | 211 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/Path.h: 212 | 213 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.h: 214 | 215 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Intrinsics.gen: 216 | 217 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/LoopInfo.h: 218 | 219 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMap.h: 220 | 221 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseMapInfo.h: 222 | 223 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DenseSet.h: 224 | 225 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Analysis/Dominators.h: 226 | 227 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/DepthFirstIterator.h: 228 | 229 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/SmallPtrSet.h: 230 | 231 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Constants.h: 232 | 233 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Module.h: 234 | 235 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalAlias.h: 236 | 237 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/GlobalVariable.h: 238 | 239 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Metadata.h: 240 | 241 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/Instructions.h: 242 | 243 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SourceMgr.h: 244 | 245 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/SMLoc.h: 246 | 247 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IR/LLVMContext.h: 248 | 249 | /home/zjr/HLSModel/llvm-3.4/include/llvm/IRReader/IRReader.h: 250 | 251 | /home/zjr/HLSModel/llvm-3.4/include/llvm/ADT/Statistic.h: 252 | 253 | /home/zjr/HLSModel/llvm-3.4/include/llvm/Support/InstIterator.h: 254 | --------------------------------------------------------------------------------