1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/* GRT stack implementation for Win32
Copyright (C) 2004, 2005 Felix Bertram.
GHDL is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.
GHDL is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/
//-----------------------------------------------------------------------------
// Project: GHDL - VHDL Simulator
// Description: Win32 port of stacks package
// Note: Tristan's original i386/Linux used assembly-code
// to manually switch stacks for performance reasons.
// History: 2004feb09, FB, created.
//-----------------------------------------------------------------------------
#include <windows.h>
//#include <pthread.h>
//#include <stdlib.h>
//#include <stdio.h>
//#define INFO printf
#define INFO (void)
// GHDL names an endless loop calling FUNC with ARG a 'stack'
// at a given time, only one stack may be 'executed'
typedef struct
{ HANDLE thread; // stack's thread
HANDLE mutex; // mutex to suspend/resume thread
void (*Func)(void*); // stack's FUNC
void* Arg; // ARG passed to FUNC
} Stack_Type_t, *Stack_Type;
Stack_Type_t main_stack_context;
extern Stack_Type grt_stack_main_stack;
//------------------------------------------------------------------------------
void grt_stack_init(void)
// Initialize the stacks package.
// This may adjust stack sizes.
// Must be called after grt.options.decode.
// => procedure Stack_Init;
{ INFO("grt_stack_init\n");
INFO(" main_stack_context=0x%08x\n", &main_stack_context);
// create event. reset event, as we are currently running
main_stack_context.mutex = CreateEvent(NULL, // lpsa
FALSE, // fManualReset
FALSE, // fInitialState
NULL); // lpszEventName
grt_stack_main_stack= &main_stack_context;
}
//------------------------------------------------------------------------------
static unsigned long __stdcall grt_stack_loop(void* pv_myStack)
{
Stack_Type myStack= (Stack_Type)pv_myStack;
INFO("grt_stack_loop\n");
INFO(" myStack=0x%08x\n", myStack);
// block until event becomes set again.
// this happens when this stack is enabled for the first time
WaitForSingleObject(myStack->mutex, INFINITE);
// run stack's function in endless loop
while(1)
{ INFO(" call 0x%08x with 0x%08x\n", myStack->Func, myStack->Arg);
myStack->Func(myStack->Arg);
}
// we never get here...
return 0;
}
//------------------------------------------------------------------------------
Stack_Type grt_stack_create(void* Func, void* Arg)
// Create a new stack, which on first execution will call FUNC with
// an argument ARG.
// => function Stack_Create (Func : Address; Arg : Address) return Stack_Type;
{ Stack_Type newStack;
DWORD m_IDThread; // Thread's ID (dummy)
INFO("grt_stack_create\n");
INFO(" call 0x%08x with 0x%08x\n", Func, Arg);
newStack= malloc(sizeof(Stack_Type_t));
// init function and argument
newStack->Func= Func;
newStack->Arg= Arg;
// create event. reset event, so that thread will blocked in grt_stack_loop
newStack->mutex= CreateEvent(NULL, // lpsa
FALSE, // fManualReset
FALSE, // fInitialState
NULL); // lpszEventName
INFO(" newStack=0x%08x\n", newStack);
// create thread, which executes grt_stack_loop
newStack->thread= CreateThread(NULL, // lpsa
0, // cbStack
grt_stack_loop, // lpStartAddr
newStack, // lpvThreadParm
0, // fdwCreate
&m_IDThread); // lpIDThread
return newStack;
}
//------------------------------------------------------------------------------
void grt_stack_switch(Stack_Type To, Stack_Type From)
// Resume stack TO and save the current context to the stack pointed by
// CUR.
// => procedure Stack_Switch (To : Stack_Type; From : Stack_Type);
{ INFO("grt_stack_switch\n");
INFO(" from 0x%08x to 0x%08x\n", From, To);
// set 'To' event. this will make the other thread either
// - start for first time in grt_stack_loop
// - resume at WaitForSingleObject below
SetEvent(To->mutex);
// block until 'From' event becomes set again
// as we are running, our event is reset and we block here
// when stacks are switched, with above SetEvent, we may proceed
WaitForSingleObject(From->mutex, INFINITE);
}
//------------------------------------------------------------------------------
void grt_stack_delete(Stack_Type Stack)
// Delete stack STACK, which must not be currently executed.
// => procedure Stack_Delete (Stack : Stack_Type);
{ INFO("grt_stack_delete\n");
}
//------------------------------------------------------------------------------
void __gnat_raise_storage_error(void)
{
abort ();
}
void __gnat_raise_program_error(void)
{
abort ();
}
//------------------------------------------------------------------------------
// end of file
|
