-
Notifications
You must be signed in to change notification settings - Fork 10
/
Copy pathChangelog
262 lines (149 loc) · 8.58 KB
/
Changelog
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
Version 0.12-0
* Support for LLVM 15 (enums, compiles, etc.)
* getGlobalContext() has a new = FALSE parameter and allows one to create new LLVMContext
instances.
* setOpaquePointers() is set by default to FALSE on the global context. However, one can
create new LLVMContext instances which default to opaque and then use opaque pointers in
that instance.
* To generate IR code with typed pointers from C/C++ source code, add -Xclang
-no-opaque-pointers to the call to clang -S -emit-llvm. (https://llvm.org/docs/OpaquePointers.html)
* mkCallProxy() can generate a proxy routine that we can invoke via .Call() rather than .llvm().
* Cleanup and documentation of code in TU/ to generate code for Rllvm and to explore LLVM
and Rllvm C++ and R code.
Version 0.10-0
* Compiles with LLVM 11.0
* copyFunction() and assignment of a Function to a module (mod$name = Function).
* createCall() can handle function pointers and not just Function objects.
* getTypes() for a Module. Returns named list of the composite/aggregate/struct types.
* Functions to read the debugging information from a Module, typically generated with -g -S -emit-llvm, but possibly with the DIBuilder
* Fixed the enum values that should have been -1L but were 4294967295L and giving (28) warnings during installation.
* Functions for querying and setting attributes on Arguments in Function objects.
* getIncomingBlock()
* Added getType() method for integer to return Int32Type so that createGlobalVariable() with an integer value for val but without a
type will work. We may remove this and it is always better to specify the desired type.
* names() and [[ name ]] methods for BasicBlock class, e.g. names(b) and b[["val"]].
* demangle() function can also be used to check the status of the demangling, i.e. whether it worked or not.
* Additional and additions to case studies in AnalyzeCCode.
* Added checks in createGEP() for the indices, i.e., fail for NA values and non-integer llvm::Value indices, and coerce R values to integer.
* $ and [[ methods for ExecutionEngine to get routines and global variables, analogous to those for Module(). But this checks all the Modules in the ExecutionEngine.
* findCalledFunctions() finds the Functions that are called (directly or indirectly) within a can Module and so can be used to identify missing Functions.
* .llvm() has a .asPointer parameter that allows the caller to indicate the return type should be treated as equivanelt to a void *, which is important when the return type is int8* and could be interpreted as a character string/array.
* When creating a call to a routine from a different modulee, createCall() will copy a declaration for that routine into the current module.
* Catch errors in ExecutionEngine so avoid preventable crashes.
Version 0.9-0
* To differentiate between StringType and generic pointers, we add metadata to the module
for the return type of a Function. (Will add more support for parameters, etc.)
* show() method for the different SEXPType objects displays their class to differentiate
them. Same for StringType.
Version 0.8-0
* getSuccessor(), getNumSuccessors() deal with ReturnInst correctly.
* moveAfter() generic and method for Block
Version 0.7-0
* insertAtEnd() function to put a instruction at the end of a block. The instruction should
probably be a terminator.
* .llvm() has a .duplicate argument that allows the caller to control which arguments are
explicitly duplicated before the call. .llvm() guesses based on readonly variables and is
conservative otherwise, leading potentially to unnecessary copies.
* getMetadata(module) method to get all the metadata elements in the Modue.
* Constructors for additional Pass objects -
createAgressiveDCEPass(), reateDeadCodeEliminationPass(), createDeadStoreEliminationPass()
* Function[[ name ]] method
* getNULLPointer() function
* createConstant() with a type converts the value to that.
* getValue() and methods for different types of Constant types.
* getNULLPointer() used, for example, when initializing
global variables that are pointers.
* getCondition() for BranchInst objects.
* isInBounds() and isInBounds()<-
* byVal() and byVal()<-
* Better error handling for parserIR()
* Update enum definitions for 3.4
* Minor changes for LLVM 3.4 (fields in TargetOptions that were removed)
Version 0.6-0
* added generatePTX() to convert Module to PTX code. See Rnvvm and libNVVM
for other an additional approach.
* added support specifying address space when creating pointer types
* added CreateFPTrunc() and CreateTrunc()
* added llvmDump() to examine instructions in IR form
* added setMetadata(), getMetadata() and getNumOperands() & getOperands()
* eraseFromParent(), removeFromParent()
* insertBefore(), insertAfter(), moveBefore()
* isa() for Instruction classes.
* More support for raw and formatted ostreams
* setDataLayout() method for Module.
Version 0.5-0
* show() methods for Module, Function, Type to make the
objects more informative when displayed.
* export getBlocks() function.
* sapply() method for iterating over a block
* get function attributes
* Set and get attributes on parameters
* Access parameters as Argument objects, e.g. fun[[1]]
* createLocalVariable() allows the instruction to be inserted
before the terminator of the current block.
* Added llvmShutdown(), llvmStartMultiThreaded(), llvmStopMultiThreaded()
* Methods for getContext().
* Methods for setAlignment() for Store, Load and Alloca instructions.
* Errors verifying a module are reported as a regular error
and not printed on the console.
* Retrieve global variable arrays as R objects.
* createStructGEP() function.
* ExecutionEngine() supports specifying optimization level.
* createGlobalVariable() initializes array types with constantAggregateZero.
* constantAggregateZero() function.
* llvmAddSymbol() also accepts the names and resolves the
corresponding symbols itself. So we can mix symbols and
strings as arguments.
* <Removed> Put a typeName attribute on the type external pointers to
be able to identify them in R. This unfortunately causes identical()
on the external pointers fail in some cases in sameType().
* Export *SXPType variables representing the type definitions
for different R types, i.e. logical, integer, numeric, ...,
ANY/SEXP. Removes the need to call getSEXPType('typeName')
* getLLVMTargets() returns the names of the available targets
for code generation.
* New interfaces to IRBuilder methods.
* Types for representing SEXP types in routines.
* Ability to pass R objects (SEXPs) to and from routines.
* Support for passing a value to a routine expecting a Float.
* changed .llvm() to alias .llvmCallFunction() rather than
run() to avoid the overhead of method dispatch.
* Support for intrinsics.
Version 0.4-2
* Support for building from the LLVM subversion repository
for version 3.2 of LLVM. See FAQ.xml.
Version 0.4-1
* ArrayType, VectorType, StructType.
* Methods for Instruction class. (Machine generated)
* Compiles and installs with LLVM 3.1.
* parseIR() function allows us to parse IR code and so we
could create the code via strings.
Version 0.4-0
* Added getDescription() and method for Type and getTypeID(),
getScalarType().
* Added createFPToSI() and createSIToFP().
Version 0.3-0
* The package automatically calls InitializeNativeTarget()
unless the R option Rllvm.autoInitialize is set to FALSE
before the package is loaded.
* Added getTerminator(), getInsertBlock()
* Implemented getting logical constants for TRUE and FALSE.
Version 0.2-1
* Method for Optimize referred to a free variable rather than
a parameter.
* Added getModuleFunctions(), getBlocks(), getPassManager()
Version 0.2-0
* The Optimize function and methods are now extended and
apply to the code via creating a FunctionPassManager and
invoking its run() method (in C++ for now).
This can work on modules or individual functions.
* getModuleFunctions() allows us to get the list of functions
in a module.
* showModule() returns the content as a string, but can also
write on the console/stdout().
We might make it possible to write to a connection in the
future.
* Additional examples in experiments/ that show constant
folding, avoiding temporary variables.
Version 0.1-0
* Addition to configuration to check suitable version of llvm available on the machine.