Skip to content

Commit

Permalink
Merge branch 'feature/32/codegen_into_ir_func' into develop
Browse files Browse the repository at this point in the history 
* feature/32/codegen_into_ir_func:
  Forces IR functions to be inlined
  Rewrites doAssignInstance with `@setInstanceInContext'
  Rewrites doAssignInstance using cached `@getObjectFieldPtr'
  Fixes using of `@getTempsFromContext'
  Rewrites primitive::arrayAtPut using cached `@getObjectFieldPtr'
  Rewrites doPushInstance using cached `@getInstanceFromContext'
  Rewrites doPushArgument using cached `@getArgFromContext'
  Rewrites doPushLiteral using TJITContext::getLiteral
  Rewrites TJITContext::getLiteral using cached `@getLiteralFromContext'
  Rewrites doAssignTemporary with `@setTemporaryInContext'
  Rewrites doPushArgument with `@getTemporaryFromContext'
  Adds function to_string to format names of llvm values
  Removes extra space in `@setObjectField'
  Rewrites `@getObjectFields' using `@getObjectFieldPtr'

Issue: #32
  • Loading branch information
@0x7CFE
0x7CFE committed Apr 12, 2015
2 parents f9dea21 + f46f391 commit 859dc6e
Show file tree
Hide file tree
Showing 3 changed files with 112 additions and 92 deletions.
74 changes: 49 additions & 25 deletions include/Core.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -153,23 +153,23 @@
;;;;;;;;;;;;;;;;;;;; functions ;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

define i1 @isSmallInteger(%TObject* %value) {
define i1 @isSmallInteger(%TObject* %value) alwaysinline {
; return reinterpret_cast<int32_t>(value) & 1;

%int = ptrtoint %TObject* %value to i32
%result = trunc i32 %int to i1
ret i1 %result
}

define i32 @getIntegerValue(%TObject* %value) {
define i32 @getIntegerValue(%TObject* %value) alwaysinline {
; return (int32_t) (value >> 1)

%int = ptrtoint %TObject* %value to i32
%result = ashr i32 %int, 1
ret i32 %result
}

define %TObject* @newInteger(i32 %value) {
define %TObject* @newInteger(i32 %value) alwaysinline {
; return reinterpret_cast<TObject>( (value << 1) | 1 );

%shled = shl i32 %value, 1
Expand All @@ -178,7 +178,7 @@ define %TObject* @newInteger(i32 %value) {
ret %TObject* %result
}

define i32 @getSlotSize(i32 %fieldsCount) {
define i32 @getSlotSize(i32 %fieldsCount) alwaysinline {
;sizeof(TObject) + fieldsCount * sizeof(TObject*)

%fieldsSize = mul i32 4, %fieldsCount
Expand All @@ -188,44 +188,44 @@ define i32 @getSlotSize(i32 %fieldsCount) {
}


define i32 @getObjectSize(%TObject* %this) {
define i32 @getObjectSize(%TObject* %this) alwaysinline {
%1 = getelementptr %TObject* %this, i32 0, i32 0, i32 0
%data = load i32* %1
%result = lshr i32 %data, 2
ret i32 %result
}

define %TObject* @setObjectSize(%TObject* %this, i32 %size) {
define %TObject* @setObjectSize(%TObject* %this, i32 %size) alwaysinline {
%addr = getelementptr %TObject* %this, i32 0, i32 0, i32 0
%ssize = shl i32 %size, 2
store i32 %ssize, i32* %addr
ret %TObject* %this
}

define i1 @isObjectRelocated(%TObject* %this) {
define i1 @isObjectRelocated(%TObject* %this) alwaysinline {
%1 = getelementptr %TObject* %this, i32 0, i32 0, i32 0
%data = load i32* %1
%field = and i32 %data, 1
%result = trunc i32 %field to i1
ret i1 %result
}

define i1 @isObjectBinary(%TObject* %this) {
define i1 @isObjectBinary(%TObject* %this) alwaysinline {
%1 = getelementptr %TObject* %this, i32 0, i32 0, i32 0
%data = load i32* %1
%field = and i32 %data, 2
%result = icmp ne i32 %field, 0
ret i1 %result
}

define %TClass** @getObjectClassPtr(%TObject* %this) {
define %TClass** @getObjectClassPtr(%TObject* %this) alwaysinline {
%pclass = getelementptr inbounds %TObject* %this, i32 0, i32 1
ret %TClass** %pclass
}

@SmallInt = external global %TClass

define %TClass* @getObjectClass(%TObject* %this) {
define %TClass* @getObjectClass(%TObject* %this) alwaysinline {
; TODO SmallInt case
%test = call i1 @isSmallInteger(%TObject* %this)
br i1 %test, label %is_smallint, label %is_object
Expand All @@ -237,46 +237,44 @@ is_object:
ret %TClass* %class
}


define %TObject* @setObjectClass(%TObject* %this, %TClass* %class) {
define %TObject* @setObjectClass(%TObject* %this, %TClass* %class) alwaysinline {
%addr = call %TClass** @getObjectClassPtr(%TObject* %this)
store %TClass* %class, %TClass** %addr
ret %TObject* %this
}

define %TObject** @getObjectFields(%TObject* %this) {
%fields = getelementptr inbounds %TObject* %this, i32 0, i32 2
%result = getelementptr inbounds [0 x %TObject*]* %fields, i32 0, i32 0
ret %TObject** %result
}

define %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index) {
define %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index) alwaysinline {
%fields = getelementptr inbounds %TObject* %object, i32 0, i32 2
%fieldPtr = getelementptr inbounds [0 x %TObject*]* %fields, i32 0, i32 %index
ret %TObject** %fieldPtr
}

define %TObject* @getObjectField(%TObject* %object, i32 %index) {
define %TObject** @getObjectFields(%TObject* %this) alwaysinline {
%fieldsPtr = call %TObject** @getObjectFieldPtr(%TObject* %this, i32 0)
ret %TObject** %fieldsPtr
}

define %TObject* @getObjectField(%TObject* %object, i32 %index) alwaysinline {
%fieldPtr = call %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index)
%result = load %TObject** %fieldPtr
ret %TObject* %result
}

define %TObject** @setObjectField(%TObject* %object, i32 %index, %TObject* %value) {
%fieldPtr = call %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index)
define %TObject** @setObjectField(%TObject* %object, i32 %index, %TObject* %value) alwaysinline {
%fieldPtr = call %TObject** @getObjectFieldPtr(%TObject* %object, i32 %index)
store %TObject* %value, %TObject** %fieldPtr
ret %TObject** %fieldPtr
}

define %TObject* @getArgFromContext(%TContext* %context, i32 %index) {
define %TObject* @getArgFromContext(%TContext* %context, i32 %index) alwaysinline {
%argsPtr = getelementptr inbounds %TContext* %context, i32 0, i32 2
%args = load %TObjectArray** %argsPtr
%argsObj = bitcast %TObjectArray* %args to %TObject*
%arg = call %TObject* @getObjectField(%TObject* %argsObj, i32 %index)
ret %TObject* %arg
}

define %TObject* @getLiteralFromContext(%TContext* %context, i32 %index) {
define %TObject* @getLiteralFromContext(%TContext* %context, i32 %index) alwaysinline {
%methodPtr = getelementptr inbounds %TContext* %context, i32 0, i32 1
%method = load %TMethod** %methodPtr
%literalsPtr = getelementptr inbounds %TMethod* %method, i32 0, i32 3
Expand All @@ -286,13 +284,39 @@ define %TObject* @getLiteralFromContext(%TContext* %context, i32 %index) {
ret %TObject* %literal
}

define %TObject* @getTempsFromContext(%TContext* %context) {
define %TObject* @getTempsFromContext(%TContext* %context) alwaysinline {
%tempsPtr = getelementptr inbounds %TContext* %context, i32 0, i32 3
%temps = load %TObjectArray** %tempsPtr
%tempsObj = bitcast %TObjectArray* %temps to %TObject*
ret %TObject* %tempsObj
}

define %TObject* @getTemporaryFromContext(%TContext* %context, i32 %index) alwaysinline {
%temps = call %TObject* @getTempsFromContext(%TContext* %context)
%temporary = call %TObject* @getObjectField(%TObject* %temps, i32 %index)
ret %TObject* %temporary
}

define void @setTemporaryInContext(%TContext* %context, i32 %index, %TObject* %value) alwaysinline {
%temps = call %TObject* @getTempsFromContext(%TContext* %context)
call %TObject** @setObjectField(%TObject* %temps, i32 %index, %TObject* %value)
ret void
}

define %TObject* @getInstanceFromContext(%TContext* %context, i32 %index) alwaysinline {
%self = call %TObject* @getArgFromContext(%TContext* %context, i32 0)
%instance = call %TObject* @getObjectField(%TObject* %self, i32 %index)
ret %TObject* %instance
}

define void @setInstanceInContext(%TContext* %context, i32 %index, %TObject* %value) alwaysinline {
%self = call %TObject* @getArgFromContext(%TContext* %context, i32 0)
%instancePtr = call %TObject** @getObjectFieldPtr(%TObject* %self, i32 %index)
call void @checkRoot(%TObject* %value, %TObject** %instancePtr)
store %TObject* %value, %TObject** %instancePtr
ret void
}

define void @dummy() gc "shadow-stack" {
; enabling shadow stack init on this module
ret void
Expand Down
14 changes: 14 additions & 0 deletions include/jit.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -142,10 +142,17 @@ struct TBaseFunctions {
llvm::Function* getObjectClass;
llvm::Function* setObjectClass;
llvm::Function* getObjectFields;
llvm::Function* getObjectFieldPtr;
llvm::Function* getObjectField;
llvm::Function* setObjectField;
llvm::Function* getSlotSize;
llvm::Function* getLiteral;
llvm::Function* getArgument;
llvm::Function* getInstance;
llvm::Function* setInstance;
llvm::Function* getTemps;
llvm::Function* getTemporary;
llvm::Function* setTemporary;

void initializeFromModule(llvm::Module* module) {
isSmallInteger = module->getFunction("isSmallInteger");
Expand All @@ -156,10 +163,17 @@ struct TBaseFunctions {
getObjectClass = module->getFunction("getObjectClass");
setObjectClass = module->getFunction("setObjectClass");
getObjectFields = module->getFunction("getObjectFields");
getObjectFieldPtr= module->getFunction("getObjectFieldPtr");
getObjectField = module->getFunction("getObjectField");
setObjectField = module->getFunction("setObjectField");
getSlotSize = module->getFunction("getSlotSize");
getLiteral = module->getFunction("getLiteralFromContext");
getArgument = module->getFunction("getArgFromContext");
getInstance = module->getFunction("getInstanceFromContext");
setInstance = module->getFunction("setInstanceInContext");
getTemps = module->getFunction("getTempsFromContext");
getTemporary = module->getFunction("getTemporaryFromContext");
setTemporary = module->getFunction("setTemporaryInContext");
}
};

Expand Down
Loading

0 comments on commit 859dc6e

Please sign in to comment.