Author: gabor
Date: Mon Mar 7 23:41:33 2005
New Revision: 9805
Modified:
branches/llvm-backend/cback.dylan
branches/llvm-backend/llvm-glue.cc
Log:
job: 7241
an attempt at GetElementPtr glue (on C++ side).
cleanups.
Modified: branches/llvm-backend/cback.dylan
==============================================================================
--- branches/llvm-backend/cback.dylan (original)
+++ branches/llvm-backend/cback.dylan Mon Mar 7 23:41:33 2005
@@ -138,6 +138,7 @@
{ <llvm-module> } => { "Module" }
{ <llvm-function> } => { "Function" }
{ <llvm-argument> } => { "Argument" }
+ { <llvm-add-instruction> } => { "BinaryAdd" }
end;
@@ -204,6 +205,24 @@
+define functional class <llvm-binary-instruction>(<llvm-instruction>)
+
+end;
+
+define functional class <llvm-add-instruction>(<llvm-binary-instruction>)
+
+end;
+
+define llvm-glue <llvm-add-instruction> ()
+ make, (left :: <llvm-value>, right :: <llvm-value>,
+ name :: <byte-string> = "",
+ before :: false-or(<llvm-instruction>),
+ atEnd :: false-or(<llvm-basic-block>)), ptr: left.raw-value,
+ ptr: right.raw-value,
+ ptr: name.object-address,
+ ptr: (atEnd |
$null-pointer).raw-value,
+ ptr: (before |
$null-pointer).raw-value;
+end;
// ################
@@ -217,16 +236,6 @@
virtual slot terminator :: <llvm-instruction>;
end;
-/*
-define method make (c == <llvm-basic-block>, #rest rest,
- #key name :: <byte-string> = "",
- into :: false-or(<llvm-function>),
- before :: false-or(<llvm-basic-block>))
- => (result :: <llvm-basic-block>);
- next-method(c, pointer: call-out("make_llvm_BasicBlock", ptr:, ptr:
name.object-address, ptr: raw-value(into | $null-pointer), ptr:
raw-value(before | $null-pointer)));
-end;
-*/
-
define llvm-glue <llvm-basic-block> ()
make, (name :: <byte-string> = "",
into :: false-or(<llvm-function>),
@@ -243,16 +252,6 @@
virtual slot next :: <llvm-function>;
end;
-/*
-define method make (f == <llvm-function>, #rest rest, #key type ::
<llvm-function-type>, name :: <byte-string> = "", module ::
false-or(<llvm-module>))
- => (result :: <llvm-function>);
- next-method(f, pointer: call-out("make_llvm_Function", ptr:,
- ptr: type.raw-value,
- ptr: name.object-address,
- ptr: raw-value(module | $null-pointer)));
-end;
-*/
-
define llvm-glue <llvm-function> ()
make, (type :: <llvm-function-type>,
name :: <byte-string> = "",
@@ -292,13 +291,6 @@
*/
end;
-/*
-define method make (m == <llvm-module>, #rest rest, #key name :: <byte-string>
= "")
- => (result :: <llvm-module>);
- next-method(m, pointer: call-out("make_llvm_Module", ptr:, ptr:
name.object-address));
-end;
-*/
-
define llvm-glue <llvm-module> ()
delete, () => ();
dump, () => ();
@@ -328,10 +320,12 @@
func.dump;
let f = make(<llvm-function>, name: "main", type: func, module: m);
- make(<llvm-argument>, type: inttype, name: "foo", func: f);
+ let arg = make(<llvm-argument>, type: inttype, name: "foo", func: f);
let bb = make(<llvm-basic-block>, name: "body", into: f);
- make(<llvm-return-instruction>, atEnd: bb);
+ let retu = make(<llvm-return-instruction>, atEnd: bb);
+
+ make(<llvm-add-instruction>, left: arg, right: arg, before: retu);
m.dump;
m.delete;
Modified: branches/llvm-backend/llvm-glue.cc
==============================================================================
--- branches/llvm-backend/llvm-glue.cc (original)
+++ branches/llvm-backend/llvm-glue.cc Mon Mar 7 23:41:33 2005
@@ -21,6 +21,7 @@
typedef ELEM* iterator;
typedef const ELEM* const_iterator;
+ std::size_t size(void) const { return elems; }
iterator begin(void) { return arr; }
iterator end(void) { return arr + elems; }
const_iterator begin(void) const { return arr; }
@@ -81,8 +82,9 @@
LLVM_MAKE_SIMPLE(ReturnInst, (/*val, beforeinstr*/ BasicBlock* atEnd), (atEnd))
+// desc_const_iterator
template <typename T>
-struct desc_const_iterator // : std::random_access_iterator<T, std::ptrdiff_t>
+struct desc_const_iterator
{
desc_const_iterator(const desc* d)
: d(d)
@@ -102,6 +104,29 @@
const desc* d;
};
+// desc_iterator
+template <typename T>
+struct desc_iterator
+{
+ desc_iterator(const desc* d)
+ : d(d)
+ {}
+
+ T operator * (void) const { return extract(*d, static_cast<T*>(0)); }
+ std::ptrdiff_t operator - (const desc_iterator<T>& rhs) const { return d -
rhs.d; }
+ desc_iterator<T>& operator ++ (void) { ++d; return *this; }
+
+private:
+ static inline long extract(const desc& d, long*)
+ { return d.dataword.l; }
+
+ static inline T extract(const desc& d, T*)
+ { return static_cast<T>(d.dataword.ptr); }
+
+ const desc* d;
+};
+
+// iterator_traits
namespace std {
template <typename T>
struct iterator_traits< desc_const_iterator<T> >
@@ -110,16 +135,47 @@
typedef T value_type;
typedef ptrdiff_t difference_type;
};
+
+ template <typename T>
+ struct iterator_traits< desc_iterator<T> >
+ {
+ typedef typename iterator_traits<T*>::iterator_category iterator_category;
+ typedef T value_type;
+ typedef ptrdiff_t difference_type;
+ };
}
LLVM_MAKE(FunctionType, (const Type* result, const SimpleObjectVector*
argtypes, bool isVarArg))
{
typedef desc_const_iterator<const Type*> extr;
- std::vector<const Type*> params(extr(argtypes->begin()),
extr(argtypes->end()));
+ const std::vector<const Type*> params(extr(argtypes->begin()),
extr(argtypes->end()));
return FunctionType::get(result, params, isVarArg);
}
+
+LLVM_MAKE(GetElementPtrInst, (Value* ptr, const SimpleObjectVector* indices,
const ByteString* name, BasicBlock* atEnd, Instruction* before))
+{
+ typedef desc_iterator<Value*> extr;
+ const extr first(indices->begin());
+ if (2 == indices->size())
+ {
+ extr second(first);
+ ++second;
+ return before
+ ? new GetElementPtrInst(ptr, *first, *second, *name, before)
+ : new GetElementPtrInst(ptr, *first, *second, *name, atEnd);
+ }
+ else
+ {
+ const std::vector<Value*> inds(first, extr(indices->end()));
+ return before
+ ? new GetElementPtrInst(ptr, inds, *name, before)
+ : new GetElementPtrInst(ptr, inds, *name, atEnd);
+ }
+}
+
+
LLVM_MAKE_SIMPLE(Argument, (const Type* ty, const ByteString* name, Function*
fun), (ty, *name, fun))
/*
LLVM_MAKE_SIMPLE(, , )
@@ -133,33 +189,13 @@
: BinaryOperator::create(op, v1, v2, *name, atEnd);
}
-/*
-BinaryOperator* make_llvm_Add(Value* v1, Value* v2, const ByteString* name,
BasicBlock* atEnd, Instruction* before)
-{
- return make_llvm_BinaryOperator(Instruction::Add, v1, v2, name, atEnd,
before);
-}
-*/
-
-typedef BinaryOperator
- BinaryAdd,
- BinarySub,
- BinaryMul,
- BinaryDiv,
- BinaryRem,
- BinaryAnd,
- BinaryOr,
- BinaryXor,
- BinarySetEQ,
- BinarySetNE,
- BinarySetLE,
- BinarySetGE,
- BinarySetLT,
- BinarySetGT;
-
#define LLVM_MAKE_BINARY(OP) \
+ typedef BinaryOperator Binary ## OP; \
LLVM_MAKE(Binary ## OP, (Value* v1, Value* v2, const ByteString* name,
BasicBlock* atEnd, Instruction* before)) \
{ return make_llvm_BinaryOperator(Instruction::OP, v1, v2, name, atEnd,
before); }
+
+/*
LLVM_MAKE_BINARY(Add)
LLVM_MAKE_BINARY(Sub)
LLVM_MAKE_BINARY(Mul)
@@ -174,6 +210,26 @@
LLVM_MAKE_BINARY(SetGE)
LLVM_MAKE_BINARY(SetLT)
LLVM_MAKE_BINARY(SetGT)
+*/
+
+#define HANDLE_BINARY_INST(num, opcode, Class) \
+ LLVM_MAKE_BINARY(opcode)
+
+
+#include "/usr/local/include/llvm/Instruction.def"
+//#include "llvm/Instructions.def"
+
+
+/*
+// Memory operators...
+ FIRST_MEMORY_INST(21)
+HANDLE_MEMORY_INST(21, Malloc, MallocInst) // Heap management instructions
+HANDLE_MEMORY_INST(22, Free , FreeInst )
+HANDLE_MEMORY_INST(23, Alloca, AllocaInst) // Stack management
+HANDLE_MEMORY_INST(24, Load , LoadInst ) // Memory manipulation instrs
+HANDLE_MEMORY_INST(25, Store , StoreInst )
+HANDLE_MEMORY_INST(26, GetElementPtr, GetElementPtrInst)
+*/
#define LLVM_DELETER(CLASS) \
--
Gd-chatter mailing list
Gd-chatter@xxxxxxxxxxxxxxxx
https://gauss.gwydiondylan.org/mailman/listinfo/gd-chatter
|
