Windows 64 bit kernel boots up to kernel and can execute a producer consumer pattern (exclusive / wait / scheduling working)

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@7414 8c9fc860-2736-0410-a75d-ab315db34111

source/Generic.Win64.Kernel32.Mod

@@ -321,9 +321,9 @@ TYPE
 		wProcessorArchitecture*: INTEGER;
 		wReserved: INTEGER;
 		dwPageSize*: LONGINT;
-		lpMinimumApplicationAddress*: LONGINT;
-		lpMaximumApplicationAddress*: LONGINT;
-		dwActiveProcessorMask*: LONGINT;
+		lpMinimumApplicationAddress*: ADDRESS;
+		lpMaximumApplicationAddress*: ADDRESS;
+		dwActiveProcessorMask*: ADDRESS;
 		dwNumberOfProcessors*: LONGINT;
 		dwProcessorType*: LONGINT;
 		dwAllocationGranularity*: LONGINT;
@@ -845,14 +845,18 @@ VAR
 	PROCEDURE SendToDebugger*(CONST str: ARRAY OF CHAR;  x: ADDRESS );
 	VAR s: ARRAY 16 OF CHAR;
 		d: ADDRESS; i: SIZE;
+		pad: ARRAY 256 OF CHAR;
 	BEGIN
-		outputDebugString( str );  s[8] := 0X;
-		FOR i := 7 TO 0 BY -1 DO
-			d := x MOD 16;
-			IF d < 10 THEN s[i] := CHR( d + ORD( "0" ) ) ELSE s[i] := CHR( d - 10 + ORD( "A" ) ) END;
-			x := x DIV 16
+		IF IsDebuggerPresent() = True THEN
+			OutputDebugString( str );  
+			s[8] := 0X;
+			FOR i := 7 TO 0 BY -1 DO
+				d := x MOD 16;
+				IF d < 10 THEN s[i] := CHR( d + ORD( "0" ) ) ELSE s[i] := CHR( d - 10 + ORD( "A" ) ) END;
+				x := x DIV 16
+			END;
+			OutputDebugString( s );  s[0] := 0AX;  s[1] := 0X;  OutputDebugString( s )
 		END;
-		outputDebugString( s );  s[0] := 0AX;  s[1] := 0X;  outputDebugString( s )
 	END SendToDebugger;
 
 	PROCEDURE ShutdownP(l: LONGINT);

source/Heaps.Mod

@@ -145,8 +145,8 @@ TYPE
 
 	TypeInfo*= POINTER{UNSAFE} TO TypeInfoDesc;
 	TypeInfoDesc = RECORD
-		descSize: LONGINT;
-		sentinel: LONGINT;	(* = MPO-4 *)
+		descSize: SIZE;
+		sentinel: ADDRESS;	(* = MPO-4 *)
 		tag: ADDRESS; (* pointer to static type descriptor, only used by linker and loader *)
 		flags: SET;
 		mod: ADDRESS; (* module *)

source/Win64.Machine.Mod

@@ -536,18 +536,20 @@ VAR res: LONGINT;
 BEGIN
 	IF traceName[0] # 0X THEN
 		Trace.String("removing "); Trace.String(traceName); Trace.Ln;
-		Trace.Char := LogChar;
+		(*Trace.Char := LogChar;*)
 		res := Kernel32.CloseHandle(hout);
+		TRACE(res); 
 		IF res = 0 THEN
 			res := Kernel32.GetLastError();
 			Trace.String("could not close "); Trace.String("; res = "); Trace.Int(res,1); Trace.Ln;
 		END;
 		res := Kernel32.DeleteFile(traceName);
+		TRACE(res); 
 		IF res = 0 THEN
 			res := Kernel32.GetLastError();
 			Trace.String("could not delete "); Trace.String(traceName); Trace.String("; res = "); Trace.Int(res,1); Trace.Ln;
 		END;
-
+		TRACE(res);
 	END;
 END RemoveTraceFile;
 
@@ -1007,43 +1009,57 @@ VAR trace: ARRAY 2 OF CHAR;
 BEGIN trace[0] := c; trace[1] := 0X; Kernel32.OutputString (trace);
 END LogChar;
 
-PROCEDURE -GetEAX*(): LONGINT;
-CODE{SYSTEM.i386}
-END GetEAX;
-
-PROCEDURE -GetECX*(): LONGINT;
-CODE{SYSTEM.i386}
-	MOV EAX,ECX
-END GetECX;
-
-PROCEDURE -SetEAX*(n: LONGINT);
-CODE{SYSTEM.i386}	POP EAX
-END SetEAX;
-
-PROCEDURE -SetEBX*(n: LONGINT);
-CODE{SYSTEM.i386}
-	POP EBX
-END SetEBX;
-
-PROCEDURE -SetECX*(n: LONGINT);
-CODE{SYSTEM.i386}
-	POP ECX
-END SetECX;
-
-PROCEDURE -SetEDX*(n: LONGINT);
-CODE{SYSTEM.i386}
-	POP EDX
-END SetEDX;
-
-PROCEDURE -SetESI*(n: LONGINT);
-CODE{SYSTEM.i386}
-	POP ESI
-END SetESI;
-
-PROCEDURE -SetEDI*(n: LONGINT);
-CODE{SYSTEM.i386}
-	POP EDI
-END SetEDI;
+PROCEDURE -GetRAX*(): HUGEINT;
+CODE{SYSTEM.AMD64}
+END GetRAX;
+
+PROCEDURE -GetRCX*(): HUGEINT;
+CODE{SYSTEM.AMD64}
+	MOV RAX,RCX
+END GetRCX;
+
+PROCEDURE -GetRSI*(): HUGEINT;
+CODE{SYSTEM.AMD64}
+	MOV RAX,RSI
+END GetRSI;
+
+PROCEDURE -GetRDI*(): HUGEINT;
+CODE{SYSTEM.AMD64}
+	MOV RAX,RDI
+END GetRDI;
+
+
+PROCEDURE -SetRAX*(n: HUGEINT);
+CODE{SYSTEM.AMD64}	
+	NOP
+	POP RAX
+END SetRAX;
+
+PROCEDURE -SetRBX*(n: HUGEINT);
+CODE{SYSTEM.AMD64}
+	NOP
+	POP RBX
+END SetRBX;
+
+PROCEDURE -SetRCX*(n: HUGEINT);
+CODE{SYSTEM.AMD64}
+	POP RCX
+END SetRCX;
+
+PROCEDURE -SetRDX*(n: HUGEINT);
+CODE{SYSTEM.AMD64}
+	POP RDX
+END SetRDX;
+
+PROCEDURE -SetRSI*(n: HUGEINT);
+CODE{SYSTEM.AMD64}
+	POP RSI
+END SetRSI;
+
+PROCEDURE -SetRDI*(n: HUGEINT);
+CODE{SYSTEM.AMD64}
+	POP RDI
+END SetRDI;
 
 PROCEDURE Portin8*(port: LONGINT; VAR val: CHAR);
 CODE{SYSTEM.i386}

source/Win64.Objects.Mod

@@ -610,15 +610,16 @@ END ExcpFrmHandler;
 (*	PROCEDURE -GetCur 64H, 8BH, 0DH, 0, 0, 0, 0;   (* MOV ECX, FS:[0] *) *)
 (* Better *)
 PROCEDURE -GetCur;
-CODE {SYSTEM.i386}
-	DB	064H, 08BH, 00DH, 000H, 000H, 000H, 000H
+CODE {SYSTEM.AMD64}
+	MOV RCX, [GS:0]
+	; DB	064H, 08BH, 00DH, 000H, 000H, 000H, 000H
 END GetCur;
 
 PROCEDURE GetCurrent( ): Kernel32.ExcpFrmPtr;
 VAR cur: Kernel32.ExcpFrmPtr;
 BEGIN
 	GetCur;
-	cur := SYSTEM.VAL(Kernel32.ExcpFrmPtr,Machine.GetECX());
+	cur := SYSTEM.VAL(Kernel32.ExcpFrmPtr,Machine.GetRCX());
 	(* RETURN ECX *)
 	RETURN cur
 END GetCurrent;
@@ -627,13 +628,14 @@ END GetCurrent;
 (*	PROCEDURE -SetCur 64H, 0A3H, 0, 0, 0, 0;   (* MOV FS:[0], EAX *)*)
 (* Better *)
 PROCEDURE -SetCur;
-CODE {SYSTEM.i386}
-	DB	064H, 0A3H, 000H, 000H, 000H, 000H
+CODE {SYSTEM.AMD64}
+	;  DB	064H, 0A3H, 000H, 000H, 000H, 000H
+	MOV [GS:0], RAX
 END SetCur;
 
 PROCEDURE SetCurrent( cur: Kernel32.ExcpFrmPtr );
 BEGIN
-	Machine.SetEAX(SYSTEM.VAL(LONGINT,cur));
+	Machine.SetRAX(SYSTEM.VAL(LONGINT,cur));
 	 (* EAX := cur *)
 	SetCur
 END SetCurrent;
@@ -735,7 +737,6 @@ VAR t: Process;  obj: ProtectedObject; res: Kernel32.BOOL; bp,sp: ADDRESS;
 BEGIN
 	(* it may happen that the garbage collector runs right here and ignores this procedure.
 	    This is not a problem since lpParameter (being a reference to a process) is protected by the process lists *)
-
 	Machine.Acquire(Machine.Objects);
 
 	res := Kernel32.TlsSetValue(tlsIndex, SYSTEM.VAL(LONGINT, lpParameter));
@@ -840,7 +841,8 @@ BEGIN
 	ELSE  (* terminate process *)
 		t.restartPC := SYSTEM.VAL(ADDRESS, terminateProc);
 	END;
-
+	
+	
 	t.handle := Kernel32.CreateThread(0, defaultStackSize, Wrapper, t, {}, t.id);
 
 	IF TraceVerbose OR TraceOpenClose THEN
@@ -859,11 +861,12 @@ VAR t : Process; heapBlock {UNTRACED}: Heaps.HeapBlock;
 BEGIN
 	ASSERT(priority >= 0, 1000); ASSERT(priority <=Realtime, 1001);
 	SYSTEM.GET(SYSTEM.VAL(ADDRESS, obj) + Heaps.HeapBlockOffset, heapBlock);
+	
 	ASSERT(heapBlock IS Heaps.ProtRecBlock); (* protected object *)
 	IF Restart IN flags THEN INCL(flags, Resistant) END;   (* SAFE => Restart & Resistant *)
 	NewProcess(body, priority, flags, obj, t);  INC(nProcs);  (* acquires Machine.Objects lock *)
 	t.mode := Ready; Put(ready, t);
-	Machine.Release(Machine.Objects)
+	Machine.Release(Machine.Objects);
 END CreateProcess;
 
 
@@ -1108,16 +1111,17 @@ BEGIN
 END Terminate;
 
 PROCEDURE Init;   (* can not use NEW *)
-VAR lock: PROCEDURE(obj: ProtectedObject; exclusive: BOOLEAN);
+(*VAR lock: PROCEDURE(obj: ProtectedObject; exclusive: BOOLEAN);
 	unlock: PROCEDURE(obj: ProtectedObject; dummy: BOOLEAN);
 	await: PROCEDURE(cond: Condition; slink: LONGINT; obj: ProtectedObject; flags: SET);
 	create: PROCEDURE(body: Body; priority: LONGINT; flags: SET; obj: ProtectedObject);
+	*)
 VAR t: Process;  fn: Heaps.FinalizerNode;  proc: Kernel32.HANDLE;
 	res: Kernel32.BOOL;
 BEGIN
 	Kernel32.InitializeCriticalSection(excplock);
 	numberOfProcessors := Machine.NumberOfProcessors();
-	lock := Lock; unlock := Unlock; await := Await; create := CreateProcess;
+(*	lock := Lock; unlock := Unlock; await := Await; create := CreateProcess;*)
 
 	NEW(t);  NEW(fn);
 
@@ -1143,7 +1147,7 @@ BEGIN
 	Machine.Release(Machine.Objects);
 	InitEventHandling; (* implicit call of NewProcess! *)
 	InitGCHandling; (* do. *)
-	Heaps.gcStatus := GCStatusFactory()
+	Heaps.gcStatus := GCStatusFactory();
 END Init;
 
 (** Set (or reset) an event handler object's timeout value. *)
@@ -1202,7 +1206,7 @@ END CancelTimeout;
 PROCEDURE InitEventHandling;
 BEGIN
 	NEW(event); event.next := event; event.prev := event;  (* event: head of timer event queue, only a sentinel *)
-	NEW(clock)
+	NEW(clock);
 END InitEventHandling;
 
 PROCEDURE InitGCHandling;
@@ -1319,12 +1323,17 @@ BEGIN
 	ASSERT ( tlsIndex # Kernel32.TLSOutOfIndexes );
 	Kernel32.SendToDebugger("Modules.root", ADDRESSOF(Modules.root));
 	
+	
 	(* determine whether it is WOW64 environment *)
+	TRACE(Kernel32.Wow64GetThreadContext); 
+	(*
 	isWow64 := (Kernel32.Wow64GetThreadContext # NIL) & (Kernel32.Wow64GetThreadContext(Kernel32.GetCurrentThread(),lpContext) # 0); 
+	TRACE("Objects 5"); 
 	IF isWow64 THEN
 		Trace.String("Use Wow64"); Trace.Ln;
 	END;
-	Init
+	*)
+	Init;
 END Objects.
 
 (*