8000 Merge pull request #73 from brandonros/master · sha0coder/libscemu@35ca2df · GitHub
[go: up one dir, main page]
Skip to content
This repository was archived by the owner on Dec 27, 2024. It is now read-only.

Commit 35ca2df

Browse files
sha0codersha0coder
authored
Merge pull request #73 from brandonros/master
move emu to mod and fix rep vs repe
2 parents cdf854b + 236e76e commit 35ca2df

File tree

8 files changed

+241
-137
lines changed

8 files changed

+241
-137
lines changed

‎Cargo.toml

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,6 @@ documentation = "https://docs.rs/libscemu/0.4.15/libscemu/"
1010
repository = "https://github.com/sha0coder/libscemu"
1111
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
1212

13-
1413
[dependencies]
1514
iced-x86 = "1.19.0"
1615
uint = "0.9.5"

‎src/config.rs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@ pub struct Config {
1818
pub console2: bool,
1919
pub console_addr: u64,
2020
pub entry_point: u64,
21+
pub exit_position: u64,
2122
pub code_base_addr: u64,
2223
pub is_64bits: bool, // 64bits mode
2324
pub stack_trace: bool,
@@ -50,6 +51,7 @@ impl Config {
5051
console2: false,
5152
console_addr: 0,
5253
entry_point: 0x3c0000,
54+
exit_position: 0,
5355
code_base_addr: 0x3c0000,
5456
is_64bits: false,
5557
stack_trace: false,

‎src/emu/constants.rs

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,6 @@ pub const LIBS32_MAX: u64 = 0x7FFFFFFF;
1212
pub const LIBS64_MIN: u64 = 0x7FF000000000;
1313
pub const LIBS64_MAX: u64 = 0x7FFFFFFFFFFF;
1414

15-
1615
pub const STATUS_SUCCESS: u64 = 0x00000000;
1716
pub const STATUS_ACCESS_DENIED: u64 = 0xC0000022;
1817
pub const STATUS_INVALID_HANDLE: u64 = 0xC0000008;

‎src/emu/flags.rs

Lines changed: 172 additions & 74 deletions
Original file line numberDiff line numberDiff line change
@@ -86,14 +86,6 @@ impl Flags {
8686
}
8787
}
8888

89-
pub fn diff(rip: u64, pos: u64, a: Flags, b: Flags) -> String {
90-
let mut output = String::new();
91-
if a.dump() != b.dump() {
92-
output = format!("rflags: {:x} -> {:x}; ", a.dump(), b.dump());
93-
}
94-
output
95-
}
96-
9789
pub fn clear(&mut self) {
9890
self.f_cf = false;
9991
self.f_pf = false;
@@ -139,6 +131,83 @@ impl Flags {
139131
log::info!("---");
140132
}
141133

134+
pub fn diff(a: Flags, b: Flags) -> String {
135+
let mut output = String::new();
136+
// f_cf
137+
if a.f_cf != b.f_cf {
138+
output = format!("{}{}: {} -> {} ", output, "cf", a.f_cf, b.f_cf);
139+
}
140+
// f_pf
141+
if a.f_pf != b.f_pf {
142+
output = format!("{}{}: {} -> {} ", output, "pf", a.f_pf, b.f_pf);
143+
}
144+
// f_af
145+
if a.f_af != b.f_af {
146+
output = format!("{}{}: {} -> {} ", output, "af", a.f_af, b.f_af);
147+
}
148+
// f_zf
149+
if a.f_zf != b.f_zf {
150+
output = format!("{}{}: {} -> {} ", output, "zf", a.f_zf, b.f_zf);
151+
}
152+
// f_sf
153+
if a.f_sf != b.f_sf {
154+
output = format!("{}{}: {} -> {} ", output, "sf", a.f_sf, b.f_sf);
155+
}
156+
// f_tf
157+
if a.f_tf != b.f_tf {
158+
output = format!("{}{}: {} -> {} ", output, "tf", a.f_tf, b.f_tf);
159+
}
160+
// f_if
161+
if a.f_if != b.f_if {
162+
output = format!("{}{}: {} -> {} ", output, "if", a.f_if, b.f_if);
163+
}
164+
// f_df
165+
if a.f_df != b.f_df {
166+
output = format!("{}{}: {} -> {} ", output, "df", a.f_df, b.f_df);
167+
}
168+
// f_of
169+
if a.f_of != b.f_of {
170+
output = format!("{}{}: {} -> {} ", output, "of", a.f_of, b.f_of);
171+
}
172+
// f_iopl1
173+
if a.f_iopl1 != b.f_iopl1 {
174+
output = format!("{}{}: {} -> {} ", output, "iopl1", a.f_iopl1, b.f_iopl1);
175+
}
176+
// f_iopl2
177+
if a.f_iopl2 != b.f_iopl2 {
178+
output = format!("{}{}: {} -> {} ", output, "iopl2", a.f_iopl2, b.f_iopl2);
179+
}
180+
// f_nt
181+
if a.f_nt != b.f_nt {
182+
output = format!("{}{}: {} -> {} ", output, "nt", a.f_nt, b.f_nt);
183+
}
184+
// f_rf
185+
if a.f_rf != b.f_rf {
186+
output = format!("{}{}: {} -> {} ", output, "rf", a.f_rf, b.f_rf);
187+
}
188+
// f_vm
189+
if a.f_vm != b.f_vm {
190+
output = format!("{}{}: {} -> {} ", output, "vm", a.f_vm, b.f_vm);
191+
}
192+
// f_ac
193+
if a.f_ac != b.f_ac {
194+
output = format!("{}{}: {} -> {} ", output, "ac", a.f_ac, b.f_ac);
195+
}
196+
// f_vif
197+
if a.f_vif != b.f_vif {
198+
output = format!("{}{}: {} -> {} ", output, "vif", a.f_vif, b.f_vif);
199+
}
200+
// f_vip
201+
if a.f_vip != b.f_vip {
202+
output = format!("{}{}: {} -> {} ", output, "vip", a.f_vip, b.f_vip);
203+
}
204+
// f_id
205+
if a.f_id != b.f_id {
206+
output = format!("{}{}: {} -> {} ", output, "id", a.f_id, b.f_id);
207+
}
208+
output
209+
}
210+
142211
pub fn dump(&self) -> u32 {
143212
let mut flags: u32 = 0;
144213

@@ -336,77 +405,106 @@ impl Flags {
336405
//self.f_af = (value1 & 0x0f) + (value2 & 0x0f) > 0x09;
337406
}
338407

339-
340-
341-
pub fn add64(&mut self, value1: u64, value2: u64) -> u64 {
342-
let unsigned: u128 = value1 as u128 + value2 as u128;
343-
344-
self.f_sf = (unsigned as i64) < 0;
345-
self.f_zf = (unsigned & 0xffffffff_ffffffff) == 0;
346-
//self.f_pf = (unsigned & 0xff) % 2 == 0;
347-
self.calc_pf(unsigned as u8);
348-
let (result, carry) = (value2).overflowing_add(value1);
349-
let (_, overflow) = (value2 as i64).overflowing_add(value1 as i64);
350-
self.f_of = overflow;
351-
self.f_cf = carry;
352-
self.calc_af(value1, value2, result, 64);
408+
pub fn add64(&mut self, value1: u64, value2: u64, cf: bool, include_carry: bool) -> u64 {
409+
let v1 = value1;
410+
let v2 = value2;
411+
let c = if include_carry { cf as u64 } else { 0 };
353412

354-
/*
355-
let low_nibble_value1 = value1 & 0xf;
356-
let low_nibble_value2 = value2 & 0xf;
357-
self.f_af = (low_nibble_value1 > 0x7) && (low_nibble_value2 > 0x7);
358-
*/
359-
413+
let result = v1.wrapping_add(v2).wrapping_add(c);
414+
let sum = v1 as u128 + v2 as u128 + c as u128;
415+
416+
self.f_cf = sum > 0xFFFFFFFFFFFFFFFF;
417+
self.f_sf = (result as i64) < 0;
418+
self.f_zf = result == 0;
419+
self.calc_pf(result as u8);
420+
421+
let sign1 = (v1 >> 63) & 1;
422+
let sign2 = (v2 >> 63) & 1;
423+
let signr = (result >> 63) & 1;
424+
self.f_of = (sign1 == sign2) && (sign1 != signr);
425+
426+
self.calc_af(v1, v2, result, 64);
360427
result
361428
}
362-
363-
pub fn add32(&mut self, value1: u64, value2: u64) -> u64 {
364-
let unsigned: u64 = value1 + value2;
365-
366-
self.f_sf = (unsigned as i32) < 0;
367-
self.f_zf = (unsigned & 0xffffffff) == 0;
368-
//self.f_pf = (unsigned & 0xff) % 2 == 0;
369-
self.calc_pf(unsigned as u8);
370-
let (result, carry) = (value2 as u32).overflowing_add(value1 as u32);
371-
let (_, overflow) = (value2 as u32 as i32).overflowing_add(value1 as u32 as i32);
372-
self.f_of = overflow;
373-
self.f_cf = carry;
374-
self.calc_af(value1, value2, result as u64, 32);
375-
429+
430+
pub fn add32(&mut self, value1: u32, value2: u32, cf: bool, include_carry: bool) -> u64 {
431+
let result = if include_carry {
432+
value1.wrapping_add(value2).wrapping_add(cf as u32)
433+
} else {
434+
value1.wrapping_add(value2)
435+
};
436+
437+
let sum = if include_carry {
438+
value1 as u64 + value2 as u64 + cf as u64
439+
} else {
440+
value1 as u64 + value2 as u64
441+
};
442+
443+
self.f_cf = sum > 0xFFFFFFFF;
444+
self.f_sf = (result as i32) < 0;
445+
self.f_zf = result == 0;
446+
self.calc_pf(result as u8);
447+
448+
let sign1 = (value1 >> 31) & 1;
449+
let sign2 = (value2 >> 31) & 1;
450+
let signr = (result >> 31) & 1;
451+
self.f_of = (sign1 == sign2) && (sign1 != signr);
452+
453+
self.calc_af(value1 as u64, value2 as u64, result as u64, 32);
376454
result as u64
377-
}
378-
379-
pub fn add16(&mut self, value1: u64, value2: u64) -> u64 {
380-
if value1 > 0xffff || value2 > 0xffff {
381-
panic!("add16 with a bigger precision");
382-
}
383-
384-
let unsigned: u32 = value1 as u32 + value2 as u32;
385-
386-
self.f_sf = (unsigned as i16) < 0;
387-
self.f_zf = (unsigned & 0xffff) == 0;
388-
self.calc_pf(unsigned as u8);
389-
let (result, carry) = (value2 as u16).overflowing_add(value1 as u16);
390-
let (_, overflow) = (value2 as u16 as i16).overflowing_add(value1 as u16 as i16);
391-
self.f_of = overflow;
392-
self.f_cf = carry;
393-
self.calc_af(value1, value2, result as u64, 16);
394-
455+
}
456+
457+
pub fn add16(&mut self, value1: u16, value2: u16, cf: bool, include_carry: bool) -> u64 {
458+
let result = if include_carry {
459+
value1.wrapping_add(value2).wrapping_add(cf as u16)
460+
} else {
461+
value1.wrapping_add(value2)
462+
};
463+
464+
let sum = if include_carry {
465+
value1 as u32 + value2 as u32 + cf as u32
466+
} else {
467+
value1 as u32 + value2 as u32
468+
};
469+
470+
self.f_cf = sum > 0xFFFF;
471+
self.f_sf = (result as i16) < 0;
472+
self.f_zf = result == 0;
473+
self.calc_pf(result as u8);
474+
475+
let sign1 = (value1 >> 15) & 1;
476+
let sign2 = (value2 >> 15) & 1;
477+
let signr = (result >> 15) & 1;
478+
self.f_of = (sign1 == sign2) && (sign1 != signr);
479+
480+
self.calc_af(value1 as u64, value2 as u64, result as u64, 16);
395481
result as u64
396-
}
397-
398-
pub fn add8(&mut self, value1: u64, value2: u64) -> u64 {
399-
let unsigned: u16 = value1 as u8 as u16 + value2 as u8 as u16;
400-
401-
self.f_sf = (unsigned as i8) < 0;
402-
self.f_zf = (unsigned & 0xff) == 0;
403-
self.calc_pf(unsigned as u8);
404-
let (result, carry) = (value2 as u8).overflowing_add(value1 as u8);
405-
let (_, overflow) = (value2 as u8 as i8).overflowing_add(value1 as u8 as i8);
406-
self.f_of = overflow;
407-
self.f_cf = carry;
408-
self.calc_af(value1, value2, result as u64, 8);
409-
482+
}
483+
484+
pub fn add8(&mut self, value1: u8, value2: u8, cf: bool, include_carry: bool) -> u64 {
485+
let result = if include_carry {
486+
value1.wrapping_add(value2).wrapping_add(cf as u8)
487+
} else {
488+
value1.wrapping_add(value2)
489+
};
490+
491+
let sum = if include_carry {
492+
value1 as u16 + value2 as u16 + cf as u16
493+
} else {
494+
value1 as u16 + value2 as u16
495+
};
496+
497+
self.f_cf = sum > 0xFF;
498+
self.f_sf = (result as i8) < 0;
499+
self.f_zf = result == 0;
500+
self.calc_pf(result as u8);
501+
502+
let sign1 = (value1 >> 7) & 1;
503+
let sign2 = (value2 >> 7) & 1;
504+
let signr = (result >> 7) & 1;
505+
self.f_of = (sign1 == sign2) && (sign1 != signr);
506+
507+
self.calc_af(value1 as u64, value2 as u64, result as u64, 8);
410508
result as u64
411509
}
412510

0 commit comments

Comments
 (0)
0