mirror of
https://github.com/open-goal/jak-project.git
synced 2024-11-24 06:39:51 +00:00
Merge pull request #144 from water111/w/kernel-type-prop
Make some manual progress on game source
This commit is contained in:
water111
GitHub
commit
4138e5d852
@ -512,8 +512,14 @@ std::shared_ptr<IR_Atomic> try_ld(Instruction& instr, int idx) {
|
||||
|
||||
// TODO SPECIAL
|
||||
std::shared_ptr<IR_Atomic> try_lw(Instruction& instr, int idx) {
|
||||
if (instr.kind == InstructionKind::LW && instr.get_src(1).is_reg(make_gpr(Reg::S7)) &&
|
||||
instr.get_src(0).kind == InstructionAtom::IMM_SYM) {
|
||||
if (instr.kind == InstructionKind::LW && instr.get_dst(0).is_reg(make_gpr(Reg::R0)) &&
|
||||
instr.get_src(0).is_imm() && instr.get_src(0).get_imm() == 2 &&
|
||||
instr.get_src(1).is_reg(make_gpr(Reg::R0))) {
|
||||
auto op = std::make_shared<IR_Breakpoint_Atomic>();
|
||||
op->reg_info_set = true;
|
||||
return op;
|
||||
} else if (instr.kind == InstructionKind::LW && instr.get_src(1).is_reg(make_gpr(Reg::S7)) &&
|
||||
instr.get_src(0).kind == InstructionAtom::IMM_SYM) {
|
||||
// symbol load
|
||||
auto dst = instr.get_dst(0).get_reg();
|
||||
auto op = make_set_atomic(IR_Set_Atomic::SYM_LOAD, make_reg(dst, idx),
|
||||
|
||||
@ -962,6 +962,15 @@ void IR_Suspend::get_children(std::vector<std::shared_ptr<IR>>* output) const {
|
||||
(void)output;
|
||||
}
|
||||
|
||||
goos::Object IR_Breakpoint_Atomic::to_form(const LinkedObjectFile& file) const {
|
||||
(void)file;
|
||||
return pretty_print::build_list("breakpoint!");
|
||||
}
|
||||
|
||||
void IR_Breakpoint_Atomic::get_children(std::vector<std::shared_ptr<IR>>* output) const {
|
||||
(void)output;
|
||||
}
|
||||
|
||||
goos::Object IR_Begin::to_form(const LinkedObjectFile& file) const {
|
||||
std::vector<goos::Object> list;
|
||||
list.push_back(pretty_print::to_symbol("begin"));
|
||||
|
||||
@ -212,6 +212,9 @@ class IR_FloatMath1 : public virtual IR {
|
||||
std::shared_ptr<IR> arg;
|
||||
goos::Object to_form(const LinkedObjectFile& file) const override;
|
||||
void get_children(std::vector<std::shared_ptr<IR>>* output) const override;
|
||||
TP_Type get_expression_type(const TypeState& input,
|
||||
const LinkedObjectFile& file,
|
||||
DecompilerTypeSystem& dts) override;
|
||||
};
|
||||
|
||||
class IR_IntMath2 : public virtual IR {
|
||||
@ -428,6 +431,7 @@ class IR_Suspend : public virtual IR, public IR_Atomic {
|
||||
};
|
||||
|
||||
class IR_Breakpoint_Atomic : public virtual IR_Atomic {
|
||||
public:
|
||||
IR_Breakpoint_Atomic() = default;
|
||||
goos::Object to_form(const LinkedObjectFile& file) const override;
|
||||
void get_children(std::vector<std::shared_ptr<IR>>* output) const override;
|
||||
|
||||
@ -239,6 +239,13 @@ TP_Type IR_Load::get_expression_type(const TypeState& input,
|
||||
return TP_Type(TypeSpec("type"));
|
||||
}
|
||||
|
||||
if (input_type.kind == TP_Type::OBJECT_OF_TYPE && ro.offset == -4 && kind == UNSIGNED &&
|
||||
size == 4 && ro.reg.get_kind() == Reg::GPR) {
|
||||
// get type of basic likely, but misrecognized as an object.
|
||||
// occurs often in typecase-like structures because other possible types are "stripped".
|
||||
return TP_Type::make_type_object(input_type.as_typespec().base_type());
|
||||
}
|
||||
|
||||
// nice
|
||||
ReverseDerefInputInfo rd_in;
|
||||
rd_in.mem_deref = true;
|
||||
@ -299,6 +306,26 @@ TP_Type IR_FloatMath2::get_expression_type(const TypeState& input,
|
||||
}
|
||||
}
|
||||
|
||||
TP_Type IR_FloatMath1::get_expression_type(const TypeState& input,
|
||||
const LinkedObjectFile& file,
|
||||
DecompilerTypeSystem& dts) {
|
||||
(void)input;
|
||||
(void)file;
|
||||
(void)dts;
|
||||
// FLOAT_TO_INT, INT_TO_FLOAT, ABS, NEG, SQRT
|
||||
switch (kind) {
|
||||
case FLOAT_TO_INT:
|
||||
return TP_Type(TypeSpec("int"));
|
||||
case INT_TO_FLOAT:
|
||||
case ABS:
|
||||
case NEG:
|
||||
case SQRT:
|
||||
return TP_Type(TypeSpec("float"));
|
||||
default:
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
|
||||
TP_Type IR_IntMath2::get_expression_type(const TypeState& input,
|
||||
const LinkedObjectFile& file,
|
||||
DecompilerTypeSystem& dts) {
|
||||
@ -626,4 +653,12 @@ void IR_AsmOp_Atomic::propagate_types(const TypeState& input,
|
||||
end_types.get(dst_reg->reg) = TP_Type(TypeSpec("uint"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void IR_Breakpoint_Atomic::propagate_types(const TypeState& input,
|
||||
const LinkedObjectFile& file,
|
||||
DecompilerTypeSystem& dts) {
|
||||
(void)file;
|
||||
(void)dts;
|
||||
end_types = input;
|
||||
}
|
||||
@ -7,7 +7,12 @@
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
;; to move
|
||||
(define-extern name= (function basic basic symbol))
|
||||
(define-extern name= (function basic basic symbol)) ;; gstring
|
||||
(define-extern stop (function int)) ;; logic-target
|
||||
(define-extern set-blackout-frames (function int int))
|
||||
|
||||
|
||||
|
||||
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
@ -41,6 +46,8 @@
|
||||
|
||||
;; C
|
||||
(define-extern dgo-load (function string kheap int int none))
|
||||
(define-extern *kernel-boot-message* symbol)
|
||||
(define-extern *debug-segment* symbol)
|
||||
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
@ -146,11 +153,19 @@
|
||||
; ;; likely a bitfield type
|
||||
; )
|
||||
|
||||
;; gcommon
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; GSTRING-H ;;;;;;;;;;;;;;;;;;;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
|
||||
;; nothing!
|
||||
|
||||
;; gcommon
|
||||
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; GKERNEL-H ;;;;;;;;;;;;;;;;;;;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
|
||||
;; gkernel-h
|
||||
(deftype kernel-context (basic)
|
||||
@ -220,9 +235,9 @@
|
||||
(deftype process-tree (basic)
|
||||
((name basic :offset-assert 4)
|
||||
(mask uint32 :offset-assert 8)
|
||||
(parent pointer :offset-assert 12)
|
||||
(brother pointer :offset-assert 16)
|
||||
(child pointer :offset-assert 20)
|
||||
(parent (pointer process-tree) :offset-assert 12)
|
||||
(brother (pointer process-tree) :offset-assert 16)
|
||||
(child (pointer process-tree) :offset-assert 20)
|
||||
(ppointer pointer :offset-assert 24)
|
||||
(self basic :offset-assert 28)
|
||||
)
|
||||
@ -401,6 +416,16 @@
|
||||
:flag-assert #x900000048
|
||||
)
|
||||
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; GKERNEL ;;;;;;;;;;;;;;;;;;;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
|
||||
(define-extern search-process-tree (function process-tree (function symbol object) object))
|
||||
(define-extern kill-by-name (function object process-tree symbol))
|
||||
(define-extern process-by-name (function object process-tree process))
|
||||
(define-extern *active-pool* process-tree)
|
||||
|
||||
;; pskernel
|
||||
(deftype lowmemmap (structure)
|
||||
@ -424,7 +449,11 @@
|
||||
:flag-assert #x900000044
|
||||
)
|
||||
|
||||
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; DGO-H ;;;;;;;;;;;;;;;;;;;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
|
||||
;; dgo-h
|
||||
(deftype dgo-entry (structure)
|
||||
@ -450,7 +479,7 @@
|
||||
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; ENGINE TYPES ;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; MATH ;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~;
|
||||
|
||||
@ -463,6 +492,35 @@
|
||||
:flag-assert #x900000008
|
||||
)
|
||||
|
||||
(define-extern truncate (function float float))
|
||||
(define-extern integral? (function float symbol))
|
||||
(define-extern fractional-part (function float float))
|
||||
(define-extern log2 (function int int))
|
||||
(define-extern seek (function float float float float))
|
||||
(define-extern lerp (function float float float float))
|
||||
(define-extern lerp-scale (function float float float float float float))
|
||||
|
||||
; ;;(define-extern xyzwh object) ;; unknown type
|
||||
; (define-extern rand-vu-init function)
|
||||
; (define-extern rand-vu-nostep function)
|
||||
; (define-extern rand-vu function)
|
||||
; (define-extern lerp function)
|
||||
; (define-extern lerp-scale function)
|
||||
; (define-extern rand-vu-int-range function)
|
||||
; (define-extern lerp-clamp function)
|
||||
; ;;(define-extern random-generator object) ;; unknown type
|
||||
; (define-extern integral? function)
|
||||
; (define-extern rand-uint31-gen function)
|
||||
; (define-extern rand-vu-int-count function)
|
||||
; (define-extern fractional-part function)
|
||||
; (define-extern seek function)
|
||||
; ;;(define-extern xyzw object) ;; unknown type
|
||||
; (define-extern rand-vu-percent? function)
|
||||
; ;;(define-extern *random-generator* object) ;; unknown type
|
||||
; (define-extern rand-vu-float-range function)
|
||||
; ;;(define-extern rgba object) ;; unknown type
|
||||
; (define-extern seekl function)
|
||||
|
||||
; ;; vector-h
|
||||
(deftype vector (structure)
|
||||
((data float 4 :offset-assert 0)
|
||||
@ -1923,6 +1981,8 @@
|
||||
)
|
||||
)
|
||||
|
||||
(define-extern *display* display)
|
||||
|
||||
;;;;;;;;;;;;;;;
|
||||
;; file-io
|
||||
;;;;;;;;;;;;;;;
|
||||
@ -2282,116 +2342,124 @@
|
||||
:size-assert #x50
|
||||
:flag-assert #x900000050
|
||||
)
|
||||
; ;; level-h
|
||||
; (deftype level (basic)
|
||||
; ((name basic :offset-assert 4)
|
||||
; (load-name basic :offset-assert 8)
|
||||
; (nickname basic :offset-assert 12)
|
||||
; (index int32 :offset-assert 16)
|
||||
; (status basic :offset-assert 20)
|
||||
; (other basic :offset-assert 24)
|
||||
; (heap kheap :inline :offset-assert 32)
|
||||
; (bsp basic :offset-assert 48)
|
||||
; (art-group basic :offset-assert 52)
|
||||
; (info basic :offset-assert 56)
|
||||
; (texture-page UNKNOWN 9 :offset-assert 60)
|
||||
; (loaded-texture-page UNKNOWN 16 :offset-assert 96)
|
||||
; (loaded-texture-page-count int32 :offset-assert 160)
|
||||
; (foreground-sink-group UNKNOWN 3 :offset-assert 180)
|
||||
; (foreground-draw-engine UNKNOWN 3 :offset-assert 272)
|
||||
; (entity basic :offset-assert 284)
|
||||
; (ambient basic :offset-assert 288)
|
||||
; (closest-object UNKNOWN 9 :offset-assert 292)
|
||||
; (upload-size UNKNOWN 9 :offset-assert 328)
|
||||
; (level-distance meters :offset-assert 364)
|
||||
; (inside-sphere? basic :offset-assert 368)
|
||||
; (inside-boxes? basic :offset-assert 372)
|
||||
; (display? basic :offset-assert 376)
|
||||
; (meta-inside? basic :offset-assert 380)
|
||||
; (mood basic :offset-assert 384)
|
||||
; (mood-func basic :offset-assert 388)
|
||||
; (vis-bits uint32 :offset-assert 392)
|
||||
; (all-visible? basic :offset-assert 396)
|
||||
; (force-all-visible? basic :offset-assert 400)
|
||||
; (linking basic :offset-assert 404)
|
||||
; (vis-info UNKNOWN 8 :offset-assert 408)
|
||||
; (vis-self-index int32 :offset-assert 440)
|
||||
; (vis-adj-index int32 :offset-assert 444)
|
||||
; (vis-buffer UNKNOWN 2048 :offset-assert 448)
|
||||
; (mem-usage-block basic :offset-assert 2496)
|
||||
; (mem-usage int32 :offset-assert 2500)
|
||||
; (code-memory-start uint32 :offset-assert 2504)
|
||||
; (code-memory-end uint32 :offset-assert 2508)
|
||||
; (texture-mask UNKNOWN 9 :offset-assert 2512)
|
||||
; (force-inside? basic :offset-assert 2548)
|
||||
; )
|
||||
; :method-count-assert 29
|
||||
; :size-assert #xa30
|
||||
; :flag-assert #x1d00000a30
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; (dummy-10 () none 10)
|
||||
; (dummy-11 () none 11)
|
||||
; (dummy-12 () none 12)
|
||||
; (dummy-13 () none 13)
|
||||
; (dummy-14 () none 14)
|
||||
; (dummy-15 () none 15)
|
||||
; (dummy-16 () none 16)
|
||||
; (dummy-17 () none 17)
|
||||
; (dummy-18 () none 18)
|
||||
; (dummy-19 () none 19)
|
||||
; (dummy-20 () none 20)
|
||||
; (dummy-21 () none 21)
|
||||
; (dummy-22 () none 22)
|
||||
; (dummy-23 () none 23)
|
||||
; (dummy-24 () none 24)
|
||||
; (dummy-25 () none 25)
|
||||
; (dummy-26 () none 26)
|
||||
; (dummy-27 () none 27)
|
||||
; (dummy-28 () none 28)
|
||||
; )
|
||||
; )
|
||||
;; level-h
|
||||
(deftype level (basic)
|
||||
((name basic :offset-assert 4)
|
||||
(load-name basic :offset-assert 8)
|
||||
(nickname basic :offset-assert 12)
|
||||
(index int32 :offset-assert 16)
|
||||
(status basic :offset-assert 20)
|
||||
(other basic :offset-assert 24)
|
||||
(heap kheap :inline :offset-assert 32)
|
||||
(bsp basic :offset-assert 48)
|
||||
(art-group basic :offset-assert 52)
|
||||
(info basic :offset-assert 56)
|
||||
(texture-page basic 9 :offset-assert 60)
|
||||
(loaded-texture-page basic 16 :offset-assert 96)
|
||||
(loaded-texture-page-count int32 :offset-assert 160)
|
||||
(foreground-sink-group dma-foreground-sink-group 3 :inline :offset-assert 176) ;; inline basic
|
||||
(foreground-draw-engine basic 3 :offset-assert 272)
|
||||
(entity basic :offset-assert 284)
|
||||
(ambient basic :offset-assert 288)
|
||||
(closest-object basic 9 :offset-assert 292)
|
||||
(upload-size uint32 9 :offset-assert 328)
|
||||
(level-distance float :offset-assert 364) ; meters
|
||||
(inside-sphere? basic :offset-assert 368)
|
||||
(inside-boxes? basic :offset-assert 372)
|
||||
(display? basic :offset-assert 376)
|
||||
(meta-inside? basic :offset-assert 380)
|
||||
(mood basic :offset-assert 384)
|
||||
(mood-func basic :offset-assert 388)
|
||||
(vis-bits uint32 :offset-assert 392)
|
||||
(all-visible? basic :offset-assert 396)
|
||||
(force-all-visible? basic :offset-assert 400)
|
||||
(linking basic :offset-assert 404)
|
||||
(vis-info level-vis-info 8 :offset-assert 408)
|
||||
(vis-self-index int32 :offset-assert 440)
|
||||
(vis-adj-index int32 :offset-assert 444)
|
||||
(vis-buffer uint8 2048 :offset-assert 448)
|
||||
(mem-usage-block basic :offset-assert 2496)
|
||||
(mem-usage int32 :offset-assert 2500)
|
||||
(code-memory-start uint32 :offset-assert 2504)
|
||||
(code-memory-end uint32 :offset-assert 2508)
|
||||
(texture-mask uint32 9 :offset-assert 2512)
|
||||
(force-inside? basic :offset-assert 2548)
|
||||
(pad uint8 56)
|
||||
)
|
||||
:method-count-assert 29
|
||||
:size-assert #xa30
|
||||
:flag-assert #x1d00000a30
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
(dummy-10 () none 10)
|
||||
(dummy-11 () none 11)
|
||||
(dummy-12 () none 12)
|
||||
(dummy-13 () none 13)
|
||||
(dummy-14 () none 14)
|
||||
(dummy-15 () none 15)
|
||||
(dummy-16 () none 16)
|
||||
(dummy-17 () none 17)
|
||||
(dummy-18 () none 18)
|
||||
(dummy-19 () none 19)
|
||||
(dummy-20 () none 20)
|
||||
(dummy-21 () none 21)
|
||||
(dummy-22 () none 22)
|
||||
(dummy-23 () none 23)
|
||||
(dummy-24 () none 24)
|
||||
(dummy-25 () none 25)
|
||||
(dummy-26 () none 26)
|
||||
(dummy-27 () none 27)
|
||||
(dummy-28 () none 28)
|
||||
)
|
||||
)
|
||||
|
||||
; ;; level-h
|
||||
; (deftype level-group (basic)
|
||||
; ((length int32 :offset-assert 4)
|
||||
; (entity-link entity-links :offset-assert 16)
|
||||
; (border? basic :offset-assert 20)
|
||||
; (vis? basic :offset-assert 24)
|
||||
; (want-level basic :offset-assert 28)
|
||||
; (receiving-level basic :offset-assert 32)
|
||||
; (load-commands basic :offset-assert 36)
|
||||
; (play? basic :offset-assert 40)
|
||||
; (level UNKNOWN 3 :offset-assert 100)
|
||||
; (data UNKNOWN 3 :offset-assert 100)
|
||||
; (level0 level :inline :offset-assert 100)
|
||||
; (level1 level :inline :offset-assert 2708)
|
||||
; (level-default level :inline :offset-assert 5316)
|
||||
; )
|
||||
; :method-count-assert 27
|
||||
; :size-assert #x1ef4
|
||||
; :flag-assert #x1b00001ef4
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; (dummy-10 () none 10)
|
||||
; (dummy-11 () none 11)
|
||||
; (dummy-12 () none 12)
|
||||
; (dummy-13 () none 13)
|
||||
; (dummy-14 () none 14)
|
||||
; (dummy-15 () none 15)
|
||||
; (dummy-16 () none 16)
|
||||
; (dummy-17 () none 17)
|
||||
; (dummy-18 () none 18)
|
||||
; (dummy-19 () none 19)
|
||||
; (dummy-20 () none 20)
|
||||
; (dummy-21 () none 21)
|
||||
; (dummy-22 () none 22)
|
||||
; (dummy-23 () none 23)
|
||||
; (dummy-24 () none 24)
|
||||
; (dummy-25 () none 25)
|
||||
; (dummy-26 () none 26)
|
||||
; )
|
||||
; )
|
||||
|
||||
|
||||
|
||||
(declare-type entity-links structure)
|
||||
;; level-h
|
||||
(deftype level-group (basic)
|
||||
((length int32 :offset-assert 4)
|
||||
(entity-link entity-links :offset 16) ;; not sure what's going on here
|
||||
(border? basic :offset-assert 20)
|
||||
(vis? basic :offset-assert 24)
|
||||
(want-level basic :offset-assert 28)
|
||||
(receiving-level basic :offset-assert 32)
|
||||
(load-commands basic :offset-assert 36)
|
||||
(play? basic :offset-assert 40)
|
||||
; (level UNKNOWN 3 :offset-assert 100)
|
||||
; (data UNKNOWN 3 :offset-assert 100)
|
||||
(level0 level :inline :offset 96) ;; inline basic
|
||||
(level1 level :inline :offset-assert 2704) ;; inline basic
|
||||
(level-default level :inline :offset-assert 5312) ;; inline basic
|
||||
(pad uint32)
|
||||
)
|
||||
:method-count-assert 27
|
||||
:size-assert #x1ef4
|
||||
:flag-assert #x1b00001ef4
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
(dummy-10 () none 10)
|
||||
(dummy-11 () none 11)
|
||||
(dummy-12 () none 12)
|
||||
(dummy-13 () none 13)
|
||||
(dummy-14 () none 14)
|
||||
(dummy-15 () none 15)
|
||||
(dummy-16 () none 16)
|
||||
(dummy-17 () none 17)
|
||||
(dummy-18 () none 18)
|
||||
(dummy-19 () none 19)
|
||||
(dummy-20 () none 20)
|
||||
(dummy-21 () none 21)
|
||||
(dummy-22 () none 22)
|
||||
(dummy-23 () none 23)
|
||||
(dummy-24 () none 24)
|
||||
(dummy-25 () none 25)
|
||||
(dummy-26 () none 26)
|
||||
)
|
||||
)
|
||||
|
||||
(define-extern *level* level-group)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;
|
||||
;; math-camera-h
|
||||
@ -2692,36 +2760,75 @@
|
||||
;; settings-h
|
||||
;;;;;;;;;;;;;;;;
|
||||
|
||||
; ;; settings-h
|
||||
; (deftype setting-data (structure)
|
||||
; ()
|
||||
; :method-count-assert 10
|
||||
; :size-assert #xc4
|
||||
; :flag-assert #xa000000c4
|
||||
; ;; too many basic blocks
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; )
|
||||
; )
|
||||
;; settings-h
|
||||
;; was manually done
|
||||
(deftype setting-data (structure)
|
||||
((border-mode basic :offset-assert 0)
|
||||
(sfx-volume float :offset-assert 4)
|
||||
(music-volume float :offset-assert 8)
|
||||
(dialog-volume float :offset-assert 12)
|
||||
(process-mask uint32 :offset-assert 16)
|
||||
(common-page int32 :offset-assert 20)
|
||||
(language int64 :offset-assert 24)
|
||||
(screenx int32 :offset-assert 32)
|
||||
(screeny int32 :offset-assert 36)
|
||||
(vibration basic :offset-assert 40)
|
||||
(play-hints basic :offset-assert 44)
|
||||
(movie basic :offset-assert 48) ;; special print
|
||||
(talking basic :offset-assert 52) ;; special print
|
||||
(spooling basic :offset-assert 56) ;; special print
|
||||
(hint basic :offset-assert 60) ;; special print
|
||||
(ambient basic :offset-assert 64) ;; special print
|
||||
(video-mode basic :offset-assert 68)
|
||||
(aspect-ratio basic :offset-assert 72)
|
||||
(sound-flava uint8 :offset-assert 76)
|
||||
(auto-save basic :offset-assert 80)
|
||||
(music-volume-movie float :offset-assert 84)
|
||||
(sfx-volume-movie float :offset-assert 88)
|
||||
(music basic :offset-assert 92)
|
||||
(bg-r float :offset-assert 96)
|
||||
(bg-g float :offset-assert 100)
|
||||
(bg-b float :offset-assert 104)
|
||||
(bg-a float :offset-assert 108)
|
||||
(bg-a-speed float :offset-assert 112)
|
||||
(bg-a-force float :offset-assert 116)
|
||||
(allow-progress basic :offset-assert 120)
|
||||
(allow-pause basic :offset-assert 124)
|
||||
(sound-flava-priority float :offset-assert 128)
|
||||
(ocean-off basic :offset-assert 132)
|
||||
(allow-look-around basic :offset-assert 136)
|
||||
(ambient-volume float :offset-assert 140)
|
||||
(ambient-volume-movie float :offset-assert 144)
|
||||
(dialog-volume-hint float :offset-assert 148)
|
||||
(dummy uint32 11 :offset-assert 152)
|
||||
|
||||
)
|
||||
:method-count-assert 10
|
||||
:size-assert #xc4
|
||||
:flag-assert #xa000000c4
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
)
|
||||
)
|
||||
|
||||
; ;; settings-h
|
||||
; (deftype setting-control (basic)
|
||||
; ((current setting-data :inline :offset-assert 16)
|
||||
; (target setting-data :inline :offset-assert 224)
|
||||
; (default setting-data :inline :offset-assert 432)
|
||||
; (engine basic :offset-assert 628)
|
||||
; )
|
||||
; :method-count-assert 14
|
||||
; :size-assert #x278
|
||||
; :flag-assert #xe00000278
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; (dummy-10 () none 10)
|
||||
; (dummy-11 () none 11)
|
||||
; (dummy-12 () none 12)
|
||||
; (dummy-13 () none 13)
|
||||
; )
|
||||
; )
|
||||
;; settings-h
|
||||
(deftype setting-control (basic)
|
||||
((current setting-data :inline :offset-assert 16)
|
||||
(target setting-data :inline :offset-assert 224)
|
||||
(default setting-data :inline :offset-assert 432)
|
||||
(engine basic :offset-assert 628)
|
||||
)
|
||||
:method-count-assert 14
|
||||
:size-assert #x278
|
||||
:flag-assert #xe00000278
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
(dummy-10 () none 10)
|
||||
(dummy-11 () none 11)
|
||||
(dummy-12 () none 12)
|
||||
(dummy-13 () none 13)
|
||||
)
|
||||
)
|
||||
|
||||
(deftype scf-time (structure)
|
||||
((stat uint8 :offset-assert 0)
|
||||
@ -2738,6 +2845,7 @@
|
||||
:flag-assert #x900000008
|
||||
)
|
||||
|
||||
(define-extern *setting-control* setting-control)
|
||||
|
||||
;;;;;;;;;;;;;;;;;
|
||||
;; capture
|
||||
@ -2833,6 +2941,8 @@
|
||||
)
|
||||
)
|
||||
|
||||
(define-extern *dproc* process)
|
||||
|
||||
;;;;;;;;;;;;;;
|
||||
;; mspace-h
|
||||
;;;;;;;;;;;;;;
|
||||
@ -4219,6 +4329,8 @@
|
||||
;; inherited inpspect of process
|
||||
)
|
||||
|
||||
(define-extern *time-of-day-proc* time-of-day-proc)
|
||||
|
||||
;; time-of-day-h
|
||||
(deftype time-of-day-palette (basic)
|
||||
((width int32 :offset-assert 4)
|
||||
@ -5609,37 +5721,40 @@
|
||||
(force-vis? basic :offset-assert 8)
|
||||
(force-inside? basic :offset-assert 12)
|
||||
)
|
||||
:pack-me
|
||||
:method-count-assert 9
|
||||
:size-assert #x10
|
||||
:flag-assert #x900000010
|
||||
)
|
||||
|
||||
; ;; game-info-h
|
||||
; (deftype load-state (basic)
|
||||
; ((want UNKNOWN 2 :offset-assert 4)
|
||||
; (vis-nick basic :offset-assert 36)
|
||||
; (command-list basic :offset-assert 40)
|
||||
; (object-name UNKNOWN 256 :offset-assert 44)
|
||||
; (object-status UNKNOWN 256 :offset-assert 1068)
|
||||
; )
|
||||
; :method-count-assert 21
|
||||
; :size-assert #x82c
|
||||
; :flag-assert #x150000082c
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; (dummy-10 () none 10)
|
||||
; (dummy-11 () none 11)
|
||||
; (dummy-12 () none 12)
|
||||
; (dummy-13 () none 13)
|
||||
; (dummy-14 () none 14)
|
||||
; (dummy-15 () none 15)
|
||||
; (dummy-16 () none 16)
|
||||
; (dummy-17 () none 17)
|
||||
; (dummy-18 () none 18)
|
||||
; (dummy-19 () none 19)
|
||||
; (dummy-20 () none 20)
|
||||
; )
|
||||
; )
|
||||
(deftype load-state (basic)
|
||||
((want level-buffer-state 2 :inline :offset-assert 4)
|
||||
(vis-nick basic :offset-assert 36)
|
||||
(command-list basic :offset-assert 40)
|
||||
(object-name basic 256 :offset-assert 44)
|
||||
(object-status basic 256 :offset-assert 1068)
|
||||
)
|
||||
:method-count-assert 21
|
||||
:size-assert #x82c
|
||||
:flag-assert #x150000082c
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
(dummy-10 () none 10)
|
||||
(dummy-11 () none 11)
|
||||
(dummy-12 () none 12)
|
||||
(dummy-13 () none 13)
|
||||
(dummy-14 () none 14)
|
||||
(dummy-15 () none 15)
|
||||
(dummy-16 () none 16)
|
||||
(dummy-17 () none 17)
|
||||
(dummy-18 () none 18)
|
||||
(dummy-19 () none 19)
|
||||
(dummy-20 () none 20)
|
||||
)
|
||||
)
|
||||
|
||||
(define-extern *load-state* load-state)
|
||||
|
||||
;; game-info-h
|
||||
(deftype continue-point (basic)
|
||||
@ -5740,6 +5855,8 @@
|
||||
)
|
||||
)
|
||||
|
||||
(define-extern *game-info* game-info)
|
||||
|
||||
;; wind-h
|
||||
(deftype wind-vector (structure)
|
||||
((wind-pos vector2w :inline :offset-assert 0)
|
||||
@ -8062,30 +8179,30 @@
|
||||
|
||||
;; target-h
|
||||
(deftype target (process-drawable)
|
||||
((~Tcontrol basic :offset 112)
|
||||
(~Tskel2 basic :offset-assert 176)
|
||||
(~Tracer basic :offset-assert 180)
|
||||
(~Tgame basic :offset-assert 184)
|
||||
(~Tneck basic :offset-assert 188)
|
||||
(~Tstate-hook-time uint64 :offset-assert 192)
|
||||
(~Tstate-hook basic :offset-assert 200)
|
||||
(~Tcam-user-mode basic :offset-assert 204)
|
||||
(~Tsidekick uint32 :offset-assert 208)
|
||||
(~Tmanipy uint32 :offset-assert 212)
|
||||
(~Tattack-info attack-info :inline :offset-assert 224)
|
||||
(~Tattack-info-rec attack-info :inline :offset-assert 336)
|
||||
(~Tanim-seed uint64 :offset-assert 440)
|
||||
(~Talt-cam-pos vector :inline :offset-assert 448)
|
||||
(~Tsnowball basic :offset-assert 464)
|
||||
(~Ttube basic :offset-assert 468)
|
||||
(~Tflut basic :offset-assert 472)
|
||||
(~Tcurrent-level basic :offset-assert 476)
|
||||
(~Tsaved-pos transformq :inline :offset-assert 480)
|
||||
(~Tsaved-owner uint64 :offset-assert 528)
|
||||
(~Talt-neck-pos vector :inline :offset-assert 544)
|
||||
(~Tfp-hud uint64 :offset-assert 560)
|
||||
(~Tno-load-wait uint64 :offset-assert 568)
|
||||
(~Tno-look-around-wait uint64 :offset-assert 576)
|
||||
((control basic :offset 112)
|
||||
(skel2 basic :offset-assert 176)
|
||||
(racer basic :offset-assert 180)
|
||||
(game basic :offset-assert 184)
|
||||
(neck basic :offset-assert 188)
|
||||
(state-hook-time uint64 :offset-assert 192)
|
||||
(state-hook basic :offset-assert 200)
|
||||
(cam-user-mode basic :offset-assert 204)
|
||||
(sidekick uint32 :offset-assert 208)
|
||||
(manipy uint32 :offset-assert 212)
|
||||
(attack-info attack-info :inline :offset-assert 224)
|
||||
(attack-info-rec attack-info :inline :offset-assert 336)
|
||||
(anim-seed uint64 :offset-assert 440)
|
||||
(alt-cam-pos vector :inline :offset-assert 448)
|
||||
(snowball basic :offset-assert 464)
|
||||
(tube basic :offset-assert 468)
|
||||
(flut basic :offset-assert 472)
|
||||
(current-level basic :offset-assert 476)
|
||||
(saved-pos transformq :inline :offset-assert 480)
|
||||
(saved-owner uint64 :offset-assert 528)
|
||||
(alt-neck-pos vector :inline :offset-assert 544)
|
||||
(fp-hud uint64 :offset-assert 560)
|
||||
(no-load-wait uint64 :offset-assert 568)
|
||||
(no-look-around-wait uint64 :offset-assert 576)
|
||||
)
|
||||
:heap-base #x1e0
|
||||
:method-count-assert 21
|
||||
@ -8097,6 +8214,8 @@
|
||||
)
|
||||
)
|
||||
|
||||
(define-extern *target* target)
|
||||
|
||||
;; target-h
|
||||
(deftype sidekick (process-drawable)
|
||||
((~Tcontrol basic :offset 112)
|
||||
@ -9320,52 +9439,53 @@
|
||||
; :flag-assert #x9000040b0
|
||||
; )
|
||||
|
||||
; ;; entity-h
|
||||
; (deftype entity-perm (structure)
|
||||
; ((user-object UNKNOWN 2 :offset-assert 0)
|
||||
; (user-uint64 uint64 :offset-assert 0)
|
||||
; (user-float UNKNOWN 2 :offset-assert 0)
|
||||
; (user-int32 UNKNOWN 2 :offset-assert 0)
|
||||
; (user-uint32 UNKNOWN 2 :offset-assert 0)
|
||||
; (user-int16 UNKNOWN 4 :offset-assert 0)
|
||||
; (user-uint16 UNKNOWN 4 :offset-assert 0)
|
||||
; (user-int8 UNKNOWN 8 :offset-assert 0)
|
||||
; (user-uint8 UNKNOWN 8 :offset-assert 0)
|
||||
; (status uint16 :offset-assert 8)
|
||||
; (dummy UNKNOWN 1 :offset-assert 10)
|
||||
; (task uint8 :offset-assert 11)
|
||||
; (aid uint32 :offset-assert 12)
|
||||
; (quad uint128 :offset-assert 0)
|
||||
; )
|
||||
; :method-count-assert 10
|
||||
; :size-assert #x10
|
||||
; :flag-assert #xa00000010
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; )
|
||||
; )
|
||||
;; entity-h
|
||||
(deftype entity-perm (structure)
|
||||
((user-object object 2 :offset-assert 0)
|
||||
(user-uint64 uint64 :offset 0)
|
||||
(user-float float 2 :offset 0)
|
||||
(user-int32 int32 2 :offset 0)
|
||||
(user-uint32 uint32 2 :offset 0)
|
||||
(user-int16 int16 4 :offset 0)
|
||||
(user-uint16 uint16 4 :offset 0)
|
||||
(user-int8 int8 8 :offset 0)
|
||||
(user-uint8 uint8 8 :offset 0)
|
||||
(status uint16 :offset-assert 8)
|
||||
(dummy uint8 1 :offset-assert 10)
|
||||
(task uint8 :offset-assert 11)
|
||||
(aid uint32 :offset-assert 12)
|
||||
(quad uint128 :offset 0)
|
||||
)
|
||||
:pack-me
|
||||
:method-count-assert 10
|
||||
:size-assert #x10
|
||||
:flag-assert #xa00000010
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
)
|
||||
)
|
||||
|
||||
; ;; entity-h
|
||||
; (deftype entity-links (structure)
|
||||
; ((prev-link entity-links :offset-assert 0)
|
||||
; (next-link entity-links :offset-assert 4)
|
||||
; (entity basic :offset-assert 8)
|
||||
; (process basic :offset-assert 12)
|
||||
; (level basic :offset-assert 16)
|
||||
; (vis-id int32 :offset-assert 20)
|
||||
; (trans vector :inline :offset-assert 32)
|
||||
; (perm entity-perm :inline :offset-assert 48)
|
||||
; (status uint16 :offset-assert 56)
|
||||
; (aid uint32 :offset-assert 60)
|
||||
; (task uint8 :offset-assert 59)
|
||||
; )
|
||||
; :method-count-assert 10
|
||||
; :size-assert #x40
|
||||
; :flag-assert #xa00000040
|
||||
; (:methods
|
||||
; (dummy-9 () none 9)
|
||||
; )
|
||||
; )
|
||||
;; entity-h
|
||||
(deftype entity-links (structure)
|
||||
((prev-link entity-links :offset-assert 0)
|
||||
(next-link entity-links :offset-assert 4)
|
||||
(entity basic :offset-assert 8)
|
||||
(process basic :offset-assert 12)
|
||||
(level basic :offset-assert 16)
|
||||
(vis-id int32 :offset-assert 20)
|
||||
(trans vector :inline :offset-assert 32)
|
||||
(perm entity-perm :inline :offset-assert 48)
|
||||
(status uint16 :offset 56) ;; overlays
|
||||
(aid uint32 :offset 60)
|
||||
(task uint8 :offset 59)
|
||||
)
|
||||
:method-count-assert 10
|
||||
:size-assert #x40
|
||||
:flag-assert #xa00000040
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
)
|
||||
)
|
||||
|
||||
; ;; entity-h
|
||||
; (deftype entity-perm-array (inline-array-class)
|
||||
@ -30996,7 +31116,6 @@
|
||||
(define-extern throw function)
|
||||
;;(define-extern *nk-dead-pool* object) ;; unknown type
|
||||
(define-extern kill-by-type function)
|
||||
(define-extern search-process-tree function)
|
||||
(define-extern change-to-last-brother function)
|
||||
;;(define-extern *pickup-dead-pool* object) ;; unknown type
|
||||
|
||||
@ -31023,7 +31142,6 @@
|
||||
(define-extern entity-deactivate-handler function)
|
||||
;;(define-extern *null-process* object) ;; unknown type
|
||||
(define-extern inspect-process-heap function)
|
||||
(define-extern process-by-name function)
|
||||
;;(define-extern *target-pool* object) ;; unknown type
|
||||
;;(define-extern *global-search-name* object) ;; unknown type
|
||||
;;(define-extern *kernel-boot-mode* object) ;; unknown type
|
||||
@ -31040,7 +31158,6 @@
|
||||
;;(define-extern *irx-version* object) ;; unknown type
|
||||
;;(define-extern *pause-lock* object) ;; unknown type
|
||||
;;(define-extern display-pool object) ;; unknown type
|
||||
(define-extern kill-by-name function)
|
||||
;;(define-extern *target-dead-pool* object) ;; unknown type
|
||||
;;(define-extern *vis-boot* object) ;; unknown type
|
||||
;;(define-extern *debug-dead-pool* object) ;; unknown type
|
||||
@ -31140,28 +31257,7 @@
|
||||
(define-extern inherit-state function)
|
||||
;;(define-extern time-frame object) ;; unknown type
|
||||
;;(define-extern part-id object) ;; unknown type
|
||||
(define-extern log2 function)
|
||||
;;(define-extern xyzwh object) ;; unknown type
|
||||
(define-extern rand-vu-init function)
|
||||
(define-extern truncate function)
|
||||
(define-extern rand-vu-nostep function)
|
||||
(define-extern rand-vu function)
|
||||
(define-extern lerp function)
|
||||
(define-extern lerp-scale function)
|
||||
(define-extern rand-vu-int-range function)
|
||||
(define-extern lerp-clamp function)
|
||||
;;(define-extern random-generator object) ;; unknown type
|
||||
(define-extern integral? function)
|
||||
(define-extern rand-uint31-gen function)
|
||||
(define-extern rand-vu-int-count function)
|
||||
(define-extern fractional-part function)
|
||||
(define-extern seek function)
|
||||
;;(define-extern xyzw object) ;; unknown type
|
||||
(define-extern rand-vu-percent? function)
|
||||
;;(define-extern *random-generator* object) ;; unknown type
|
||||
(define-extern rand-vu-float-range function)
|
||||
;;(define-extern rgba object) ;; unknown type
|
||||
(define-extern seekl function)
|
||||
|
||||
;;(define-extern vector2h object) ;; unknown type
|
||||
;;(define-extern vector4s-3 object) ;; unknown type
|
||||
;;(define-extern *identity-vector* object) ;; unknown type
|
||||
@ -31212,7 +31308,7 @@
|
||||
;;(define-extern bounding-box4w object) ;; unknown type
|
||||
;;(define-extern bounding-box-both object) ;; unknown type
|
||||
;;(define-extern matrix4h object) ;; unknown type
|
||||
(define-extern matrix-copy! function)
|
||||
; (define-extern matrix-copy! function)
|
||||
;;(define-extern matrix3 object) ;; unknown type
|
||||
;;(define-extern matrix object) ;; unknown type
|
||||
;;(define-extern *unity-quaternion* object) ;; unknown type
|
||||
@ -33506,12 +33602,11 @@
|
||||
;;(define-extern health object) ;; unknown type
|
||||
(define-extern set-master-mode function)
|
||||
;;(define-extern allow-progress object) ;; unknown type
|
||||
(define-extern set-blackout-frames function)
|
||||
; (define-extern set-blackout-frames function)
|
||||
(define-extern reset-actors function)
|
||||
(define-extern get-task-control function)
|
||||
;;(define-extern *kernel-boot-message* object) ;; unknown type
|
||||
(define-extern play (function none))
|
||||
(define-extern stop function)
|
||||
(define-extern auto-save-check function)
|
||||
;;(define-extern auto-save object) ;; unknown type
|
||||
;;(define-extern game-save-tag object) ;; unknown type
|
||||
|
||||
@ -70,6 +70,8 @@ void DecompilerTypeSystem::parse_type_defs(const std::vector<std::string>& file_
|
||||
}
|
||||
if (type_kind.as_symbol()->name == "basic") {
|
||||
ts.forward_declare_type_as_basic(type_name.as_symbol()->name);
|
||||
} else if (type_kind.as_symbol()->name == "structure") {
|
||||
ts.forward_declare_type_as_structure(type_name.as_symbol()->name);
|
||||
} else {
|
||||
throw std::runtime_error("bad declare-type");
|
||||
}
|
||||
|
||||
65
doc/code_status.md
Normal file
65
doc/code_status.md
Normal file
@ -0,0 +1,65 @@
|
||||
## gcommon.gc
|
||||
Missing stuff.
|
||||
|
||||
## gstring-h.gc
|
||||
Empty file.
|
||||
|
||||
## gkernel-h.gc
|
||||
Likely missing some macros. Missing `handle`, a child type of integer.
|
||||
|
||||
## gkernel.gc
|
||||
Missing lots of stuff. Will need x86-64 inline assembly and some tweaking for x86.
|
||||
|
||||
## pskernel.gc
|
||||
Possibly can be entirely left out. Seems to be mostly unused, or only used for PS2 debugging?
|
||||
|
||||
## gstring.gc
|
||||
Missing lots
|
||||
|
||||
## dgo-h.gc
|
||||
Done!
|
||||
|
||||
## gstate.gc
|
||||
Not started, probably needs state support in the compiler
|
||||
|
||||
## types.gc
|
||||
Needs child types of integer
|
||||
|
||||
## vu-macros.gc
|
||||
Empty.
|
||||
|
||||
## math.gc
|
||||
Has a unit test for a lot of functions.
|
||||
rand-vu-init, rand-vu, rand-vu-nostep, rand-vu-float-range, rand-vu-percent?, rand-vu-int-range, rand-vu-int-count aren't implemented
|
||||
|
||||
rand-uint31-gen might be wrong.
|
||||
|
||||
## vector.gc
|
||||
Partially done
|
||||
|
||||
## gravity-h.gc
|
||||
Empty file
|
||||
|
||||
## bounding-box-h.gc
|
||||
Just types. Done!
|
||||
|
||||
## matrix-h.gc
|
||||
Types and one function. Done, but the matrix-copy! function isn't that efficient.
|
||||
|
||||
## quaternion-h.gc
|
||||
Done!
|
||||
|
||||
## euler-h.gc
|
||||
Needs static arrays
|
||||
|
||||
## transform-h.gc
|
||||
Done!
|
||||
|
||||
## geometry-h.gc
|
||||
Done!
|
||||
|
||||
## trigonometry-h.gc
|
||||
Empty File.
|
||||
|
||||
## transformq-h.gc
|
||||
Not done.
|
||||
@ -210,6 +210,8 @@
|
||||
("ENGINE.CGO"
|
||||
("types-h.o" "types-h")
|
||||
("vu1-macros.o" "vu1-macros")
|
||||
|
||||
;; the "math" section
|
||||
("math.o" "math")
|
||||
("vector-h.o" "vector-h")
|
||||
("gravity-h.o" "gravity-h")
|
||||
@ -228,6 +230,8 @@
|
||||
("euler.o" "euler")
|
||||
("geometry.o" "geometry")
|
||||
("trigonometry.o" "trigonometry")
|
||||
|
||||
|
||||
("gsound-h.o" "gsound-h")
|
||||
("timer-h.o" "timer-h")
|
||||
("timer.o" "timer")
|
||||
|
||||
@ -5,3 +5,43 @@
|
||||
;; name in dgo: bounding-box-h
|
||||
;; dgos: GAME, ENGINE
|
||||
|
||||
;; Types related to bounding boxes.
|
||||
|
||||
;; floating point bounding box.
|
||||
(deftype bounding-box (structure)
|
||||
((min vector :inline :offset-assert 0)
|
||||
(max vector :inline :offset-assert 16)
|
||||
)
|
||||
:method-count-assert 16
|
||||
:size-assert #x20
|
||||
:flag-assert #x1000000020
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
(dummy-10 () none 10)
|
||||
(dummy-11 () none 11)
|
||||
(dummy-12 () none 12)
|
||||
(dummy-13 () none 13)
|
||||
(dummy-14 () none 14)
|
||||
(dummy-15 () none 15)
|
||||
)
|
||||
)
|
||||
|
||||
;; integer (word) bounding box.
|
||||
(deftype bounding-box4w (structure)
|
||||
((min vector4w :inline :offset-assert 0)
|
||||
(max vector4w :inline :offset-assert 16)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x20
|
||||
:flag-assert #x900000020
|
||||
)
|
||||
|
||||
;; bounding both that has both a box and box4w.
|
||||
(deftype bounding-box-both (structure)
|
||||
((box bounding-box :inline :offset-assert 0)
|
||||
(box4w bounding-box4w :inline :offset-assert 32)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x40
|
||||
:flag-assert #x900000040
|
||||
)
|
||||
@ -5,3 +5,32 @@
|
||||
;; name in dgo: geometry-h
|
||||
;; dgos: GAME, ENGINE
|
||||
|
||||
;; geometry-h
|
||||
(deftype curve (structure)
|
||||
((cverts uint32 :offset-assert 0)
|
||||
(num-cverts int32 :offset-assert 4)
|
||||
(knots uint32 :offset-assert 8)
|
||||
(num-knots int32 :offset-assert 12)
|
||||
(length float :offset-assert 16)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x14
|
||||
:flag-assert #x900000014
|
||||
)
|
||||
|
||||
;; geometry-h
|
||||
(deftype border-plane (basic)
|
||||
((name basic :offset-assert 4)
|
||||
(action basic :offset-assert 8)
|
||||
(slot int8 :offset-assert 12)
|
||||
(trans vector :inline :offset-assert 16)
|
||||
(normal vector :inline :offset-assert 32)
|
||||
)
|
||||
:method-count-assert 11
|
||||
:size-assert #x30
|
||||
:flag-assert #xb00000030
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
(dummy-10 () none 10)
|
||||
)
|
||||
)
|
||||
@ -5,3 +5,165 @@
|
||||
;; name in dgo: math
|
||||
;; dgos: GAME, ENGINE
|
||||
|
||||
;; contains various math helpers
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; float macros
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
;; at some point, this could be more optimized.
|
||||
;; MIPS has an explicit abs.s instruction, but x86-64 doesn't.
|
||||
;; modern clang on O3 does a comiss/branch and this is probably pretty close.
|
||||
|
||||
(defmacro fabs (x)
|
||||
`(if (< (the float ,x) 0)
|
||||
(- (the float ,x))
|
||||
(the float ,x))
|
||||
)
|
||||
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; float utility
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defun truncate ((x float))
|
||||
"Truncate a floating point number to an integer value.
|
||||
Positive values round down and negative values round up."
|
||||
(declare (inline))
|
||||
(the float (the int x))
|
||||
)
|
||||
|
||||
(defun integral? ((x float))
|
||||
"Is a float an exact integer?"
|
||||
(= (truncate x) x)
|
||||
)
|
||||
|
||||
(defun fractional-part ((x float))
|
||||
"Get the fractional part of a float"
|
||||
(- x (truncate x))
|
||||
)
|
||||
|
||||
;; todo, rgba, xyzw, xyzwh
|
||||
|
||||
(defun log2 ((x int))
|
||||
"Straight out of Bit Twiddling Hacks graphics.stanford.edu"
|
||||
(- (sarv (the-as integer (the float x)) 23) 127)
|
||||
)
|
||||
|
||||
(defun seek ((x float) (target float) (diff float))
|
||||
"Move x toward target by at most diff, with floats"
|
||||
(let ((err (- target x)))
|
||||
;; if we can get there all at once
|
||||
(if (<= (fabs err) diff)
|
||||
(return-from #f target)
|
||||
)
|
||||
|
||||
(if (>= err 0)
|
||||
(+ x diff)
|
||||
(- x diff)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
(defun lerp ((minimum float) (maximum float) (amount float))
|
||||
"Interpolate between minimum and maximum. The output is not clamped."
|
||||
(+ minimum (* amount (- maximum minimum)))
|
||||
)
|
||||
|
||||
(defun lerp-scale ((min-out float) (max-out float)
|
||||
(in float) (min-in float) (max-in float))
|
||||
"Interpolate from [min-in, max-in] to [min-out, max-out].
|
||||
If the output is out of range, it will be clamped.
|
||||
This is not a great implementation."
|
||||
(let ((scale (fmax 0.0 (fmin 1.0 (/ (- in min-in) (- max-in min-in))))))
|
||||
(+ (* (- 1.0 scale) min-out)
|
||||
(* scale max-out)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
(defun lerp-clamp ((minimum float) (maximum float) (amount float))
|
||||
"Interpolate between minimum and maximum. Clamp output.
|
||||
For some reason, the interpolate here is done in a less efficient way than lerp."
|
||||
(if (<= amount 0.0)
|
||||
(return-from #f minimum)
|
||||
)
|
||||
|
||||
(if (>= amount 1.0)
|
||||
(return-from #f maximum)
|
||||
)
|
||||
;; lerp computes this part, but more efficiently
|
||||
(+ (* (- 1.0 amount) minimum)
|
||||
(* amount maximum)
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; integer utility
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defun seekl ((x int) (target int) (diff int))
|
||||
"Move x toward a target by at most diff, with integers"
|
||||
(let ((err (- target x)))
|
||||
(if (< (abs err) diff)
|
||||
(return-from #f target)
|
||||
)
|
||||
|
||||
(if (>= err 0)
|
||||
(+ x diff)
|
||||
(- x diff)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; random vu
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
;; TODO
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
;;;; terrible random integer generator
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(deftype random-generator (basic)
|
||||
((seed uint32 :offset-assert 4)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x8
|
||||
:flag-assert #x900000008
|
||||
)
|
||||
|
||||
(define *random-generator* (new 'global 'random-generator))
|
||||
;; I wonder who wrote this code.
|
||||
(set! (-> *random-generator* seed) #x666EDD1E)
|
||||
|
||||
(defmacro sext32-64 (x)
|
||||
`(sarv (shlv ,x 32) 32)
|
||||
)
|
||||
|
||||
(defun rand-uint31-gen ((gen random-generator))
|
||||
"Generate a supposedly random integer.
|
||||
Note, this might not quite be right.
|
||||
But the highest bit is always zero, like it says
|
||||
and it looks kinda random to me."
|
||||
(let* ((sd (-> gen seed))
|
||||
;; addiu v1, r0, 16807
|
||||
;; mult3 v0, v1, a1
|
||||
(prod (imul64 16807 sd))
|
||||
;; mfhi v1
|
||||
(hi (shrv prod 32)) ;; sign extend this?
|
||||
(lo (sarv (shlv prod 32) 32))
|
||||
;; daddu v1, v1, v1
|
||||
(v1 (+ hi hi))
|
||||
;; srl a1, v0, 31
|
||||
(a1 (logand #xffffffff (shrv lo 31)))
|
||||
;; or v1, v1, a1
|
||||
;; daddu v0, v0 v1
|
||||
(result (+ lo (logior v1 a1)))
|
||||
)
|
||||
(set! result (shrv (logand #xffffffff (shlv result 1)) 1))
|
||||
(set! (-> gen seed) result)
|
||||
result
|
||||
)
|
||||
)
|
||||
@ -5,3 +5,45 @@
|
||||
;; name in dgo: matrix-h
|
||||
;; dgos: GAME, ENGINE
|
||||
|
||||
;; matrix-h
|
||||
(deftype matrix (structure)
|
||||
((data float 16 :offset-assert 0)
|
||||
(vector vector 4 :offset 0)
|
||||
(quad uint128 4 :offset 0)
|
||||
)
|
||||
:method-count-assert 10
|
||||
:size-assert #x40
|
||||
:flag-assert #xa00000040
|
||||
(:methods
|
||||
(dummy-9 () none 9)
|
||||
)
|
||||
)
|
||||
|
||||
(deftype matrix3 (structure)
|
||||
((data float 12 :offset-assert 0)
|
||||
(vector vector 3 :offset 0)
|
||||
(quad uint128 3 :offset 0)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x30
|
||||
:flag-assert #x900000030
|
||||
)
|
||||
|
||||
;; guess on signs here
|
||||
(deftype matrix4h (structure)
|
||||
((data int16 16 :offset-assert 0)
|
||||
(vector4h vector4h 4 :offset 0)
|
||||
(long int64 4 :offset 0)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x20
|
||||
:flag-assert #x900000020
|
||||
)
|
||||
|
||||
(defun matrix-copy! ((dst matrix) (src matrix))
|
||||
"Copy src to dst."
|
||||
;; actual implementation is in assembly, unrolled quad copies, loads/stores spaced out.
|
||||
(dotimes (i 16 dst)
|
||||
(set! (-> dst data i) (-> src data i))
|
||||
)
|
||||
)
|
||||
@ -5,3 +5,18 @@
|
||||
;; name in dgo: quaternion-h
|
||||
;; dgos: GAME, ENGINE
|
||||
|
||||
(deftype quaternion (structure)
|
||||
((data float 4 :offset-assert 0)
|
||||
(x float :offset 0)
|
||||
(y float :offset 4)
|
||||
(z float :offset 8)
|
||||
(w float :offset 12)
|
||||
(vec vector :inline :offset 0)
|
||||
(quad uint128 :offset 0)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x10
|
||||
:flag-assert #x900000010
|
||||
)
|
||||
|
||||
(define *unity-quaternion* (new 'static 'quaternion :x 0.0 :y 0.0 :z 0.0 :w 1.0))
|
||||
@ -5,3 +5,24 @@
|
||||
;; name in dgo: transform-h
|
||||
;; dgos: GAME, ENGINE
|
||||
|
||||
|
||||
(deftype transform (structure)
|
||||
((trans vector :inline :offset-assert 0)
|
||||
(rot vector :inline :offset-assert 16)
|
||||
(scale vector :inline :offset-assert 32)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x30
|
||||
:flag-assert #x900000030
|
||||
)
|
||||
|
||||
|
||||
(deftype trs (basic)
|
||||
((trans vector :inline :offset-assert 16)
|
||||
(rot vector :inline :offset-assert 32)
|
||||
(scale vector :inline :offset-assert 48)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x40
|
||||
:flag-assert #x900000040
|
||||
)
|
||||
@ -5,3 +5,29 @@
|
||||
;; name in dgo: dgo-h
|
||||
;; dgos: KERNEL
|
||||
|
||||
;; I suspect that these are unused, and were for an older version of DGO.
|
||||
;; All DGO stuff is handled on the IOP.
|
||||
|
||||
;; seems to be unused, and not accurate to a DGO file anyway.
|
||||
;; all DGO stuff is handled on the IOP.
|
||||
(deftype dgo-entry (structure)
|
||||
((offset uint32 :offset-assert 0)
|
||||
(length uint32 :offset-assert 4)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x8
|
||||
:flag-assert #x900000008
|
||||
)
|
||||
|
||||
;; seems to be unused, and not accurate to a DGO file anyway.
|
||||
;; all DGO stuff is handled on the IOP.
|
||||
(deftype dgo-file (basic)
|
||||
((num-go-files uint32 :offset-assert 4)
|
||||
(total-length uint32 :offset-assert 8)
|
||||
(rsvd uint32 :offset-assert 12)
|
||||
(data uint8 :dynamic :offset-assert 16)
|
||||
)
|
||||
:method-count-assert 9
|
||||
:size-assert #x10
|
||||
:flag-assert #x900000010
|
||||
)
|
||||
|
||||
@ -162,9 +162,9 @@
|
||||
(deftype process-tree (basic)
|
||||
((name basic :offset-assert 4)
|
||||
(mask uint32 :offset-assert 8)
|
||||
(parent pointer :offset-assert 12)
|
||||
(brother pointer :offset-assert 16)
|
||||
(child pointer :offset-assert 20)
|
||||
(parent (pointer process-tree) :offset-assert 12)
|
||||
(brother (pointer process-tree) :offset-assert 16)
|
||||
(child (pointer process-tree) :offset-assert 20)
|
||||
(ppointer pointer :offset-assert 24)
|
||||
(self basic :offset-assert 28)
|
||||
)
|
||||
|
||||
@ -218,9 +218,9 @@ class Compiler {
|
||||
|
||||
// Math
|
||||
Val* compile_add(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
|
||||
Val* compile_sub(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_mul(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_imul64(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_div(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_shlv(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_sarv(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
@ -231,6 +231,8 @@ class Compiler {
|
||||
Val* compile_logand(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_logior(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_pointer_add(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_fmin(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
Val* compile_fmax(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
|
||||
// Function
|
||||
Val* compile_lambda(const goos::Object& form, const goos::Object& rest, Env* env);
|
||||
|
||||
@ -400,6 +400,8 @@ std::string IR_IntegerMath::print() {
|
||||
return fmt::format("subi {}, {}", m_dest->print(), m_arg->print());
|
||||
case IntegerMathKind::IMUL_32:
|
||||
return fmt::format("imul {}, {}", m_dest->print(), m_arg->print());
|
||||
case IntegerMathKind::IMUL_64:
|
||||
return fmt::format("imul64 {}, {}", m_dest->print(), m_arg->print());
|
||||
case IntegerMathKind::IDIV_32:
|
||||
return fmt::format("idiv {}, {}", m_dest->print(), m_arg->print());
|
||||
case IntegerMathKind::IMOD_32:
|
||||
@ -483,13 +485,15 @@ void IR_IntegerMath::do_codegen(emitter::ObjectGenerator* gen,
|
||||
gen->add_instr(IGen::imul_gpr32_gpr32(dr, get_reg(m_arg, allocs, irec)), irec);
|
||||
gen->add_instr(IGen::movsx_r64_r32(dr, dr), irec);
|
||||
} break;
|
||||
|
||||
case IntegerMathKind::IMUL_64: {
|
||||
auto dr = get_reg(m_dest, allocs, irec);
|
||||
gen->add_instr(IGen::imul_gpr64_gpr64(dr, get_reg(m_arg, allocs, irec)), irec);
|
||||
} break;
|
||||
case IntegerMathKind::IDIV_32: {
|
||||
gen->add_instr(IGen::cdq(), irec);
|
||||
gen->add_instr(IGen::idiv_gpr32(get_reg(m_arg, allocs, irec)), irec);
|
||||
gen->add_instr(IGen::movsx_r64_r32(get_reg(m_dest, allocs, irec), emitter::RAX), irec);
|
||||
} break;
|
||||
|
||||
case IntegerMathKind::IMOD_32: {
|
||||
gen->add_instr(IGen::cdq(), irec);
|
||||
gen->add_instr(IGen::idiv_gpr32(get_reg(m_arg, allocs, irec)), irec);
|
||||
@ -518,6 +522,10 @@ std::string IR_FloatMath::print() {
|
||||
return fmt::format("addss {}, {}", m_dest->print(), m_arg->print());
|
||||
case FloatMathKind::SUB_SS:
|
||||
return fmt::format("subss {}, {}", m_dest->print(), m_arg->print());
|
||||
case FloatMathKind::MAX_SS:
|
||||
return fmt::format("maxss {}, {}", m_dest->print(), m_arg->print());
|
||||
case FloatMathKind::MIN_SS:
|
||||
return fmt::format("minss {}, {}", m_dest->print(), m_arg->print());
|
||||
default:
|
||||
throw std::runtime_error("Unsupported FloatMathKind");
|
||||
}
|
||||
@ -551,6 +559,14 @@ void IR_FloatMath::do_codegen(emitter::ObjectGenerator* gen,
|
||||
gen->add_instr(
|
||||
IGen::subss_xmm_xmm(get_reg(m_dest, allocs, irec), get_reg(m_arg, allocs, irec)), irec);
|
||||
break;
|
||||
case FloatMathKind::MAX_SS:
|
||||
gen->add_instr(
|
||||
IGen::maxss_xmm_xmm(get_reg(m_dest, allocs, irec), get_reg(m_arg, allocs, irec)), irec);
|
||||
break;
|
||||
case FloatMathKind::MIN_SS:
|
||||
gen->add_instr(
|
||||
IGen::minss_xmm_xmm(get_reg(m_dest, allocs, irec), get_reg(m_arg, allocs, irec)), irec);
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
}
|
||||
|
||||
@ -193,6 +193,7 @@ enum class IntegerMathKind {
|
||||
ADD_64,
|
||||
SUB_64,
|
||||
IMUL_32,
|
||||
IMUL_64,
|
||||
IDIV_32,
|
||||
SHLV_64,
|
||||
SARV_64,
|
||||
@ -223,7 +224,7 @@ class IR_IntegerMath : public IR {
|
||||
RegVal* m_arg;
|
||||
};
|
||||
|
||||
enum class FloatMathKind { DIV_SS, MUL_SS, ADD_SS, SUB_SS };
|
||||
enum class FloatMathKind { DIV_SS, MUL_SS, ADD_SS, SUB_SS, MIN_SS, MAX_SS };
|
||||
|
||||
class IR_FloatMath : public IR {
|
||||
public:
|
||||
|
||||
@ -101,6 +101,7 @@ static const std::unordered_map<
|
||||
{"+", &Compiler::compile_add},
|
||||
{"-", &Compiler::compile_sub},
|
||||
{"*", &Compiler::compile_mul},
|
||||
{"imul64", &Compiler::compile_imul64},
|
||||
{"/", &Compiler::compile_div},
|
||||
{"shlv", &Compiler::compile_shlv},
|
||||
{"shrv", &Compiler::compile_shrv},
|
||||
@ -123,6 +124,8 @@ static const std::unordered_map<
|
||||
{"<", &Compiler::compile_condition_as_bool},
|
||||
{">", &Compiler::compile_condition_as_bool},
|
||||
{"&+", &Compiler::compile_pointer_add},
|
||||
{"fmax", &Compiler::compile_fmax},
|
||||
{"fmin", &Compiler::compile_fmin},
|
||||
|
||||
// BUILDER (build-dgo/build-cgo?)
|
||||
{"build-dgos", &Compiler::compile_build_dgo},
|
||||
|
||||
@ -160,6 +160,7 @@ Val* Compiler::compile_mul(const goos::Object& form, const goos::Object& rest, E
|
||||
auto math_type = get_math_mode(first_type);
|
||||
switch (math_type) {
|
||||
case MATH_INT: {
|
||||
// todo, signed vs unsigned?
|
||||
auto result = env->make_gpr(first_type);
|
||||
env->emit(std::make_unique<IR_RegSet>(result, first_val->to_gpr(env)));
|
||||
|
||||
@ -194,6 +195,87 @@ Val* Compiler::compile_mul(const goos::Object& form, const goos::Object& rest, E
|
||||
return get_none();
|
||||
}
|
||||
|
||||
Val* Compiler::compile_fmin(const goos::Object& form, const goos::Object& rest, Env* env) {
|
||||
auto args = get_va(form, rest);
|
||||
if (!args.named.empty() || args.unnamed.empty()) {
|
||||
throw_compile_error(form, "Invalid fmin form");
|
||||
}
|
||||
|
||||
// look at the first value to determine the math mode
|
||||
auto first_val = compile_error_guard(args.unnamed.at(0), env);
|
||||
if (get_math_mode(first_val->type()) != MATH_FLOAT) {
|
||||
throw_compile_error(form, "Must use floats in fmin");
|
||||
}
|
||||
auto result = env->make_xmm(first_val->type());
|
||||
env->emit(std::make_unique<IR_RegSet>(result, first_val->to_xmm(env)));
|
||||
for (size_t i = 1; i < args.unnamed.size(); i++) {
|
||||
auto val = compile_error_guard(args.unnamed.at(i), env);
|
||||
if (get_math_mode(val->type()) != MATH_FLOAT) {
|
||||
throw_compile_error(form, "Must use floats in fmin");
|
||||
}
|
||||
env->emit(std::make_unique<IR_FloatMath>(FloatMathKind::MIN_SS, result, val->to_xmm(env)));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Val* Compiler::compile_fmax(const goos::Object& form, const goos::Object& rest, Env* env) {
|
||||
auto args = get_va(form, rest);
|
||||
if (!args.named.empty() || args.unnamed.empty()) {
|
||||
throw_compile_error(form, "Invalid fmax form");
|
||||
}
|
||||
|
||||
// look at the first value to determine the math mode
|
||||
auto first_val = compile_error_guard(args.unnamed.at(0), env);
|
||||
if (get_math_mode(first_val->type()) != MATH_FLOAT) {
|
||||
throw_compile_error(form, "Must use floats in fmax");
|
||||
}
|
||||
auto result = env->make_xmm(first_val->type());
|
||||
env->emit(std::make_unique<IR_RegSet>(result, first_val->to_xmm(env)));
|
||||
for (size_t i = 1; i < args.unnamed.size(); i++) {
|
||||
auto val = compile_error_guard(args.unnamed.at(i), env);
|
||||
if (get_math_mode(val->type()) != MATH_FLOAT) {
|
||||
throw_compile_error(form, "Must use floats in fmax");
|
||||
}
|
||||
env->emit(std::make_unique<IR_FloatMath>(FloatMathKind::MAX_SS, result, val->to_xmm(env)));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Val* Compiler::compile_imul64(const goos::Object& form, const goos::Object& rest, Env* env) {
|
||||
auto args = get_va(form, rest);
|
||||
if (!args.named.empty() || args.unnamed.empty()) {
|
||||
throw_compile_error(form, "Invalid * form");
|
||||
}
|
||||
|
||||
// look at the first value to determine the math mode
|
||||
auto first_val = compile_error_guard(args.unnamed.at(0), env);
|
||||
auto first_type = first_val->type();
|
||||
auto math_type = get_math_mode(first_type);
|
||||
switch (math_type) {
|
||||
case MATH_INT: {
|
||||
auto result = env->make_gpr(first_type);
|
||||
env->emit(std::make_unique<IR_RegSet>(result, first_val->to_gpr(env)));
|
||||
|
||||
for (size_t i = 1; i < args.unnamed.size(); i++) {
|
||||
env->emit(std::make_unique<IR_IntegerMath>(
|
||||
IntegerMathKind::IMUL_64, result,
|
||||
to_math_type(compile_error_guard(args.unnamed.at(i), env), math_type, env)
|
||||
->to_gpr(env)));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
case MATH_FLOAT:
|
||||
case MATH_INVALID:
|
||||
throw_compile_error(
|
||||
form, "Cannot determine the math mode for object of type " + first_type.print());
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
}
|
||||
assert(false);
|
||||
return get_none();
|
||||
}
|
||||
|
||||
Val* Compiler::compile_sub(const goos::Object& form, const goos::Object& rest, Env* env) {
|
||||
auto args = get_va(form, rest);
|
||||
if (!args.named.empty() || args.unnamed.empty()) {
|
||||
|
||||
@ -1387,6 +1387,19 @@ class IGen {
|
||||
return instr;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Multiply gprs (64-bit, signed).
|
||||
* DANGER - this treats all operands as 64-bit. This is not like the EE.
|
||||
*/
|
||||
static Instruction imul_gpr64_gpr64(Register dst, Register src) {
|
||||
Instruction instr(0xf);
|
||||
instr.set_op2(0xaf);
|
||||
assert(dst.is_gpr());
|
||||
assert(src.is_gpr());
|
||||
instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, true);
|
||||
return instr;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Divide (idiv, 32 bit)
|
||||
* todo UNTESTED
|
||||
@ -1727,6 +1740,34 @@ class IGen {
|
||||
return instr;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Floating point minimum.
|
||||
*/
|
||||
static Instruction minss_xmm_xmm(Register dst, Register src) {
|
||||
assert(dst.is_xmm());
|
||||
assert(src.is_xmm());
|
||||
Instruction instr(0xf3);
|
||||
instr.set_op2(0x0f);
|
||||
instr.set_op3(0x5d);
|
||||
instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
|
||||
instr.swap_op0_rex();
|
||||
return instr;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Floating point maximum.
|
||||
*/
|
||||
static Instruction maxss_xmm_xmm(Register dst, Register src) {
|
||||
assert(dst.is_xmm());
|
||||
assert(src.is_xmm());
|
||||
Instruction instr(0xf3);
|
||||
instr.set_op2(0x0f);
|
||||
instr.set_op3(0x5f);
|
||||
instr.set_modrm_and_rex(dst.hw_id(), src.hw_id(), 3, false);
|
||||
instr.swap_op0_rex();
|
||||
return instr;
|
||||
}
|
||||
|
||||
/*!
|
||||
* Convert GPR int32 to XMM float (single precision)
|
||||
*/
|
||||
|
||||
@ -0,0 +1,2 @@
|
||||
(* #x12341234 #x12341234)
|
||||
|
||||
@ -0,0 +1,2 @@
|
||||
(imul64 #x12341234 #x12341234)
|
||||
|
||||
2
test/goalc/source_templates/float/float-max.static.gc
Normal file
2
test/goalc/source_templates/float/float-max.static.gc
Normal file
@ -0,0 +1,2 @@
|
||||
(define format _format)
|
||||
(format #t "~,,2f~%" (fmax 1.0 2.0 -1.2 3.7 2.2))
|
||||
2
test/goalc/source_templates/float/float-min.static.gc
Normal file
2
test/goalc/source_templates/float/float-min.static.gc
Normal file
@ -0,0 +1,2 @@
|
||||
(define format _format)
|
||||
(format #t "~,,2f~%" (fmin 1.0 2.0 -1.2 3.7 2.2))
|
||||
41
test/goalc/source_templates/with_game/test-math.gc
Normal file
41
test/goalc/source_templates/with_game/test-math.gc
Normal file
@ -0,0 +1,41 @@
|
||||
(start-test "math")
|
||||
|
||||
(defmacro close-enough (x y)
|
||||
`(< (fabs (- ,x ,y)) 0.00001)
|
||||
)
|
||||
|
||||
(expect-eq #f (= 1.0 1.000001))
|
||||
(expect-eq #t (close-enough 1.0 1.000001))
|
||||
(expect-eq #t (= 1.0 1.00000))
|
||||
(expect-eq #t (close-enough 1.0 1.00000))
|
||||
(expect-eq #f (= 1.0 1.001))
|
||||
(expect-eq #f (close-enough 1.0 1.001))
|
||||
(expect-eq 1.0 (truncate 1.2))
|
||||
(expect-eq 1.0 (truncate 1.998))
|
||||
(expect-eq -1.0 (truncate -1.9))
|
||||
(expect-eq #t (integral? -3.0))
|
||||
(expect-eq #f (integral? 2.3))
|
||||
(expect-eq #t (close-enough -0.1 (fractional-part -1.1)))
|
||||
(expect-eq #t (close-enough 0.3 (fractional-part 4.3)))
|
||||
(expect-eq 7 (log2 128))
|
||||
(expect-eq 1.2 (fabs 1.2))
|
||||
(expect-eq 23.2 (fabs -23.2))
|
||||
(expect-eq 7.0 (seek 6. 12. 1.))
|
||||
(expect-eq 12.0 (seek 6. 12. 100.))
|
||||
(expect-eq 4.0 (seek 6.0 0.0 2.0))
|
||||
(expect-eq 0.0 (seek 6.0 0.0 200.0))
|
||||
(expect-eq 7.5 (lerp 5.0 10.0 0.5))
|
||||
(expect-eq #t (close-enough 1.5 (lerp-scale 1.0 2.0 7.5 5.0 10.0)))
|
||||
(expect-eq #t (close-enough 2.0 (lerp-scale 1.0 2.0 999.0 5.0 10.0)))
|
||||
(expect-eq #t (close-enough 1.0 (lerp-scale 1.0 2.0 -999.0 5.0 10.0)))
|
||||
|
||||
(expect-eq #t (close-enough 2.3 (lerp-clamp 1.7 2.3 100.0)))
|
||||
(expect-eq #t (close-enough 1.7 (lerp-clamp 1.7 2.3 -100.0)))
|
||||
(expect-eq #t (close-enough 7.5 (lerp-clamp 5.0 10.0 0.5)))
|
||||
|
||||
(expect-eq 3 (seekl 1 5 2))
|
||||
(expect-eq 5 (seekl 1 5 200))
|
||||
(expect-eq 1 (seekl 12 0 11))
|
||||
(expect-eq -2 (seekl 12 -2 1000))
|
||||
|
||||
(finish-test)
|
||||
@ -236,3 +236,8 @@ TEST_F(ArithmeticTests, Subtraction) {
|
||||
runner.run_static_test(env, testCategory, "subtract-2.static.gc", {"4\n"});
|
||||
runner.run_static_test(env, testCategory, "subtract-let.static.gc", {"3\n"});
|
||||
}
|
||||
|
||||
TEST_F(ArithmeticTests, Multiplication2) {
|
||||
runner.run_static_test(env, testCategory, "multiply32.static.gc", {"-1234478448\n"});
|
||||
runner.run_static_test(env, testCategory, "multiply64.static.gc", {"93270638141856400\n"});
|
||||
}
|
||||
@ -75,3 +75,8 @@ TEST_F(FloatTests, Functions) {
|
||||
env, testCategory, "nested-float-functions.static.gc",
|
||||
{"i 1.4400 3.4000\nr 10.1523\ni 1.2000 10.1523\nr 17.5432\n17.543 10.152\n0\n"});
|
||||
}
|
||||
|
||||
TEST_F(FloatTests, MinMax) {
|
||||
runner.run_static_test(env, testCategory, "float-max.static.gc", {"3.70\n0\n"});
|
||||
runner.run_static_test(env, testCategory, "float-min.static.gc", {"-1.20\n0\n"});
|
||||
}
|
||||
@ -302,9 +302,13 @@ TEST_F(WithGameTests, GameCount) {
|
||||
get_test_pass_string("game-count", 4));
|
||||
}
|
||||
|
||||
TEST_F(WithGameTests, Math) {
|
||||
runner.run_static_test(env, testCategory, "test-math.gc", get_test_pass_string("math", 31));
|
||||
}
|
||||
|
||||
TEST(TypeConsistency, TypeConsistency) {
|
||||
Compiler compiler;
|
||||
compiler.enable_throw_on_redefines();
|
||||
compiler.run_test_no_load("test/goalc/source_templates/with_game/test-build-game.gc");
|
||||
compiler.run_test_no_load("decompiler/config/all-types.gc");
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user