source: trunk/hal/tsar_mips32/core/hal_context.c @ 635

Last change on this file since 635 was 635, checked in by alain, 17 months ago

This version is a major evolution: The physical memory allocators,
defined in the kmem.c, ppm.c, and kcm.c files have been modified
to support remote accesses. The RPCs that were previously user
to allocate physical memory in a remote cluster have been removed.
This has been done to cure a dead-lock in case of concurrent page-faults.

This version 2.2 has been tested on a (4 clusters / 2 cores per cluster)
TSAR architecture, for both the "sort" and the "fft" applications.

File size: 20.5 KB
Line 
1/*
2 * hal_context.c - implementation of Thread Context API for TSAR-MIPS32
3 *
4 * Author  Alain Greiner    (2016,2017,2018,2019)
5 *
6 * Copyright (c)  UPMC Sorbonne Universites
7 *
8 * This file is part of ALMOS-MKH.
9 *
10 * ALMOS-MKH.is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2.0 of the License.
13 *
14 * ALMOS-MKH.is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with ALMOS-MKH.; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <hal_kernel_types.h>
25#include <hal_switch.h>
26#include <memcpy.h>
27#include <thread.h>
28#include <string.h>
29#include <process.h>
30#include <printk.h>
31#include <vmm.h>
32#include <bits.h>
33#include <core.h>
34#include <cluster.h>
35#include <hal_context.h>
36#include <hal_kentry.h>
37
38/////////////////////////////////////////////////////////////////////////////////////////
39//       Define various SR initialisation values for the TSAR-MIPS32 architecture.
40/////////////////////////////////////////////////////////////////////////////////////////
41
42#define SR_USR_MODE       0x0000FF13
43#define SR_USR_MODE_FPU   0x2000FF13
44#define SR_SYS_MODE       0x0000FF01
45
46/////////////////////////////////////////////////////////////////////////////////////////
47// This structure defines the CPU context for the TSAR-MIPS32 architecture.
48// The following registers are saved/restored at each context switch:
49// - GPR : all, but (zero, k0, k1), plus (hi, lo)
50// - CP0 : c0_th , c0_sr , C0_epc
51// - CP2 : c2_ptpr , C2_mode
52//
53// WARNING : check the two CONFIG_CPU_CTX_SIZE & CONFIG_FPU_CTX_SIZE configuration
54//           parameters when modifying this structure.
55/////////////////////////////////////////////////////////////////////////////////////////
56
57typedef struct hal_cpu_context_s
58{
59    uint32_t c0_epc;     // slot 0
60    uint32_t at_01;      // slot 1
61    uint32_t v0_02;      // slot 2
62    uint32_t v1_03;      // slot 3
63    uint32_t a0_04;      // slot 4
64    uint32_t a1_05;      // slot 5
65    uint32_t a2_06;      // slot 6
66    uint32_t a3_07;      // slot 7
67
68    uint32_t t0_08;      // slot 8
69    uint32_t t1_09;      // slot 9
70    uint32_t t2_10;      // slot 10
71    uint32_t t3_11;      // slot 11
72    uint32_t t4_12;      // slot 12
73    uint32_t t5_13;      // slot 13
74    uint32_t t6_14;      // slot 14
75    uint32_t t7_15;      // slot 15
76
77        uint32_t s0_16;      // slot 16
78        uint32_t s1_17;      // slot 17
79        uint32_t s2_18;      // slot 18
80        uint32_t s3_19;      // slot 19
81        uint32_t s4_20;      // slot 20
82        uint32_t s5_21;      // slot 21
83        uint32_t s6_22;      // slot 22
84        uint32_t s7_23;      // slot 23
85
86    uint32_t t8_24;      // slot 24
87    uint32_t t9_25;      // slot 25
88    uint32_t hi_26;      // slot 26
89    uint32_t lo_27;      // slot 27
90    uint32_t gp_28;      // slot 28
91        uint32_t sp_29;      // slot 29
92        uint32_t s8_30;      // slot 30
93        uint32_t ra_31;      // slot 31
94
95        uint32_t c2_ptpr;    // slot 32
96        uint32_t c2_mode;    // slot 33
97
98        uint32_t c0_sr;      // slot 34
99        uint32_t c0_th;      // slot 35
100} 
101hal_cpu_context_t;
102
103/////////////////////////////////////////////////////////////////////////////////////////
104// This structure defines the fpu_context for the TSAR MIPS32 architecture.
105/////////////////////////////////////////////////////////////////////////////////////////
106
107typedef struct hal_fpu_context_s
108{
109        uint32_t   fpu_regs[32];     
110}
111hal_fpu_context_t;
112
113
114/////////////////////////////////////////////////////////////////////////////////////////
115//        CPU context related functions
116/////////////////////////////////////////////////////////////////////////////////////////
117
118
119//////////////////////////////////////////////////
120error_t hal_cpu_context_alloc( thread_t * thread )
121{
122    assert( (sizeof(hal_cpu_context_t) <= CONFIG_CPU_CTX_SIZE) ,
123    "illegal CPU context size" );
124
125    // allocate memory for cpu_context
126    kmem_req_t  req;
127    req.type   = KMEM_KCM;
128    req.order  = bits_log2( sizeof(hal_cpu_context_t) );
129    req.flags  = AF_KERNEL | AF_ZERO;
130
131    hal_cpu_context_t * context = kmem_alloc( &req );
132
133    if( context == NULL ) return -1;
134
135    // link to thread
136    thread->cpu_context = (void *)context;
137    return 0;
138
139}   // end hal_cpu_context_alloc()
140
141/////////////////////////////////////////////////
142// The following context slots are initialised
143// GPR : a0_04 / sp_29 / ra_31
144// CP0 : c0_sr / c0_th / c0_epc
145// CP2 : c2_ptpr / c2_mode
146/////////////////////////////////////////////////
147void hal_cpu_context_init( thread_t * thread )
148{
149    hal_cpu_context_t * context = (hal_cpu_context_t *)thread->cpu_context;
150
151    assert( (context != NULL ), "CPU context not allocated" );
152
153    // initialisation depends on thread type
154    if( thread->type == THREAD_USER )
155    {
156        context->a0_04   = (uint32_t)thread->entry_args;
157        context->sp_29   = (uint32_t)thread->user_stack_vseg->max - 8;
158        context->ra_31   = (uint32_t)&hal_kentry_eret;
159        context->c0_epc  = (uint32_t)thread->entry_func;
160        context->c0_sr   = SR_USR_MODE;
161            context->c0_th   = (uint32_t)thread; 
162            context->c2_ptpr = (uint32_t)((thread->process->vmm.gpt.ppn) >> 1);
163        context->c2_mode = 0xF;
164    }
165    else  // kernel thread
166    {
167        context->a0_04   = (uint32_t)thread->entry_args;
168        context->sp_29   = (uint32_t)thread->k_stack_base + (uint32_t)thread->k_stack_size - 8;
169        context->ra_31   = (uint32_t)thread->entry_func;
170        context->c0_sr   = SR_SYS_MODE;
171            context->c0_th   = (uint32_t)thread; 
172            context->c2_ptpr = (uint32_t)((thread->process->vmm.gpt.ppn) >> 1);
173        context->c2_mode = 0x3;
174    }
175}  // end hal_cpu_context_init()
176
177////////////////////////////////////////////
178void hal_cpu_context_fork( xptr_t child_xp )
179{
180    cxy_t               parent_cxy;        // parent thread cluster
181    thread_t          * parent_ptr;        // local pointer on parent thread
182    hal_cpu_context_t * parent_context;    // local pointer on parent cpu_context
183    uint32_t          * parent_uzone;      // local_pointer on parent uzone (in kernel stack)
184    char              * parent_ksp;        // kernel stack pointer on parent kernel stack
185    uint32_t            parent_us_base;    // parent user stack base value
186
187    cxy_t               child_cxy;         // parent thread cluster
188    thread_t          * child_ptr;         // local pointer on child thread
189    hal_cpu_context_t * child_context;     // local pointer on child cpu_context
190    uint32_t          * child_uzone;       // local_pointer on child uzone (in kernel stack)
191    char              * child_ksp;         // kernel stack pointer on child kernel stack
192    uint32_t            child_us_base;     // child user stack base value
193
194    process_t         * child_process;     // local pointer on child processs
195    uint32_t            child_pt_ppn;      // PPN of child process PT1
196    vseg_t            * child_us_vseg;     // local pointer on child user stack vseg
197   
198    // allocate a local CPU context in parent kernel stack
199    hal_cpu_context_t context;
200
201    // get (local) parent thread cluster and local pointer
202    parent_cxy = local_cxy;
203    parent_ptr = CURRENT_THREAD;
204
205    // get (remote) child thread cluster and local pointer
206    child_cxy = GET_CXY( child_xp );
207    child_ptr = GET_PTR( child_xp );
208
209    // get local pointer on (local) parent CPU context
210    parent_context = parent_ptr->cpu_context;
211
212    // get local pointer on (remote) child CPU context
213    child_context = hal_remote_lpt( XPTR(child_cxy , &child_ptr->cpu_context) );
214
215    // get local pointer on remote child process
216    child_process = hal_remote_lpt( XPTR(child_cxy , &child_ptr->process) );
217
218    // get ppn of remote child process page table
219    child_pt_ppn = hal_remote_l32( XPTR(child_cxy , &child_process->vmm.gpt.ppn) );
220
221    // get local pointer on local parent uzone (in parent kernel stack)
222    parent_uzone = parent_ptr->uzone_current;
223
224    // compute local pointer on remote child uzone (in child kernel stack)
225    child_uzone  = (uint32_t *)( (intptr_t)parent_uzone +
226                                 (intptr_t)child_ptr    -
227                                 (intptr_t)parent_ptr  );
228
229    // update the uzone pointer in child thread descriptor
230    hal_remote_spt( XPTR( child_cxy , &child_ptr->uzone_current ) , child_uzone );
231
232#if DEBUG_HAL_CONTEXT
233uint32_t cycle = (uint32_t)hal_get_cycles();
234if( DEBUG_HAL_CONTEXT < cycle )
235printk("\n[%s] thread[%x,%x] parent_uzone %x / child_uzone %x / cycle %d\n",
236__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_uzone, child_uzone, cycle );
237#endif
238
239    // get user stack base for parent thread
240    parent_us_base = parent_ptr->user_stack_vseg->min;
241
242    // get user stack base for child thread
243    child_us_vseg  = hal_remote_lpt( XPTR( child_cxy , &child_ptr->user_stack_vseg ) );
244    child_us_base  = hal_remote_l32( XPTR( child_cxy , &child_us_vseg->min ) );
245
246#if DEBUG_HAL_CONTEXT
247if( DEBUG_HAL_CONTEXT < cycle )
248printk("\n[%s] thread[%x,%x] parent_ustack_base %x / child_ustack_base %x\n",
249__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_us_base, child_us_base );
250#endif
251
252    // get current value of kernel stack pointer in parent kernel stack
253    parent_ksp = (char *)hal_get_sp();
254
255    // compute value of kernel stack pointer in child kernel stack
256    child_ksp  = (char *)((intptr_t)parent_ksp +
257                          (intptr_t)child_ptr  - 
258                          (intptr_t)parent_ptr );
259
260#if DEBUG_HAL_CONTEXT
261if( DEBUG_HAL_CONTEXT < cycle )
262printk("\n[%s] thread[%x,%x] parent_ksp %x / child_ksp %x\n",
263__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_ksp, child_ksp );
264#endif
265
266    // compute number of bytes to be copied, depending on current value of parent_ksp
267    uint32_t size = (uint32_t)parent_ptr + CONFIG_THREAD_DESC_SIZE - (uint32_t)parent_ksp;   
268
269    // copy parent kernel stack content to child thread descriptor
270    // (this includes the uzone, that is allocated in the kernel stack)
271    hal_remote_memcpy( XPTR( child_cxy , child_ksp ),
272                       XPTR( local_cxy , parent_ksp ),
273                       size );
274
275#if DEBUG_HAL_CONTEXT
276if( DEBUG_HAL_CONTEXT < cycle )
277printk("\n[%s] thread[%x,%x] copied kstack from parent (%x) to child (%x)\n",
278__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, parent_ptr, child_ptr );
279#endif
280
281    // save current values of CPU registers to local copy of CPU context
282    hal_do_cpu_save( &context );
283
284    // update  three slots in this local CPU context
285    context.sp_29   = (uint32_t)child_ksp;
286    context.c0_th   = (uint32_t)child_ptr;
287    context.c2_ptpr = (uint32_t)child_pt_ppn >> 1;
288
289    // From this point, both parent and child execute the following code,
290    // but child thread will only execute it after being unblocked by parent thread.
291    // They can be distinguished by the (CURRENT_THREAD,local_cxy) values,
292    // and we must re-initialise the calling thread pointer from c0_th register
293
294    thread_t * this = CURRENT_THREAD;
295
296    if( (this == parent_ptr) && (local_cxy == parent_cxy) )   // parent thread
297    {
298        // parent thread must update four slots in child uzone
299        // - UZ_TH   : parent and child have different threads descriptors
300        // - UZ_SP   : parent and child have different user stack base addresses.
301        // - UZ_PTPR : parent and child use different Generic Page Tables
302
303        // parent thread computes values for child thread
304        uint32_t child_sp    = parent_uzone[UZ_SP]  + child_us_base - parent_us_base;
305        uint32_t child_th    = (uint32_t)child_ptr;
306        uint32_t child_ptpr  = (uint32_t)child_pt_ppn >> 1;
307
308#if DEBUG_HAL_CONTEXT
309if( DEBUG_HAL_CONTEXT < cycle )
310printk("\n[%s] thread[%x,%x] : parent_uz_sp %x / child_uz_sp %x\n",
311__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid,
312parent_uzone[UZ_SP], child_sp );
313#endif
314
315        // parent thread updates the child uzone
316        hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_SP]   ) , child_sp );
317        hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_TH]   ) , child_th );
318        hal_remote_s32( XPTR( child_cxy , &child_uzone[UZ_PTPR] ) , child_ptpr );
319
320        // parent thread copies the local context to remote child context
321        hal_remote_memcpy( XPTR( child_cxy , child_context ),
322                           XPTR( local_cxy  , &context ) , 
323                           sizeof( hal_cpu_context_t ) );
324#if DEBUG_HAL_CONTEXT
325if( DEBUG_HAL_CONTEXT < cycle )
326printk("\n[%s] thread[%x,%x] copied parent CPU context to child CPU context\n",
327__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid );
328#endif
329
330        // parent thread unblocks child thread
331        thread_unblock( XPTR( child_cxy , child_ptr ) , THREAD_BLOCKED_GLOBAL );
332
333#if DEBUG_HAL_CONTEXT
334cycle = (uint32_t)hal_get_cycles();
335trdid_t child_trdid = hal_remote_l32( XPTR( child_cxy , &child_ptr->trdid ) );
336pid_t   child_pid   = hal_remote_l32( XPTR( child_cxy , &child_process->pid ) );
337printk("\n[%s] thread[%x,%x] unblocked child thread[%x,%x] / cycle %d\n",
338__FUNCTION__, parent_ptr->process->pid, parent_ptr->trdid, child_pid, child_trdid, cycle );
339#endif
340
341    }
342
343}  // end hal_cpu_context_fork()
344
345//////////////////////////////////////////////
346void hal_cpu_context_exec( thread_t * thread )
347{
348    // re_initialize CPU context
349    hal_cpu_context_init( thread );
350
351    // restore CPU registers ... and jump to user code
352    hal_do_cpu_restore( (hal_cpu_context_t *)thread->cpu_context );
353
354} // end hal_cpu_context_exec()
355
356/////////////////////////////////////////////////
357void hal_cpu_context_display( xptr_t  thread_xp )
358{
359    hal_cpu_context_t * ctx;
360
361    // get thread cluster and local pointer
362    cxy_t      cxy = GET_CXY( thread_xp );
363    thread_t * ptr = GET_PTR( thread_xp );
364
365    // get context pointer
366    ctx = (hal_cpu_context_t *)hal_remote_lpt( XPTR( cxy , &ptr->cpu_context ) );
367
368    // get relevant context slots values
369    uint32_t sp_29   = hal_remote_l32( XPTR( cxy , &ctx->sp_29   ) );
370    uint32_t ra_31   = hal_remote_l32( XPTR( cxy , &ctx->ra_31   ) );
371    uint32_t c0_sr   = hal_remote_l32( XPTR( cxy , &ctx->c0_sr   ) );
372    uint32_t c0_epc  = hal_remote_l32( XPTR( cxy , &ctx->c0_epc  ) );
373    uint32_t c0_th   = hal_remote_l32( XPTR( cxy , &ctx->c0_th   ) );
374    uint32_t c2_ptpr = hal_remote_l32( XPTR( cxy , &ctx->c2_ptpr ) );
375    uint32_t c2_mode = hal_remote_l32( XPTR( cxy , &ctx->c2_mode ) );
376   
377    printk("\n***** CPU context for thread %x in process %x / cycle %d\n" 
378           " sp_29   = %X    ra_31   = %X\n" 
379           " c0_sr   = %X    c0_epc  = %X    c0_th = %X\n"
380           " c2_ptpr = %X    c2_mode = %X\n",
381           ptr, ptr->process->pid, (uint32_t)hal_get_cycles(),
382           sp_29   , ra_31,
383           c0_sr   , c0_epc  , c0_th,
384           c2_ptpr , c2_mode );
385
386}  // end hal_cpu_context_display()
387
388/////////////////////////////////////////////////
389void hal_cpu_context_destroy( thread_t * thread )
390{
391    kmem_req_t          req;
392
393    hal_cpu_context_t * ctx = thread->cpu_context;
394
395    // release CPU context if required
396    if( ctx != NULL )
397    {   
398        req.type = KMEM_KCM;
399        req.ptr  = ctx;
400        kmem_free( &req );
401    }
402
403}  // end hal_cpu_context_destroy()
404
405
406
407
408
409//////////////////////////////////////////////////
410error_t hal_fpu_context_alloc( thread_t * thread )
411{
412    assert( (sizeof(hal_fpu_context_t) <= CONFIG_FPU_CTX_SIZE) ,
413    "illegal CPU context size" );
414
415    // allocate memory for fpu_context
416    kmem_req_t  req;
417    req.type   = KMEM_KCM;
418    req.flags  = AF_KERNEL | AF_ZERO;
419    req.order  = bits_log2( sizeof(hal_fpu_context_t) );
420
421    hal_fpu_context_t * context = kmem_alloc( &req );
422
423    if( context == NULL ) return -1;
424
425    // link to thread
426    thread->fpu_context = (void *)context;
427    return 0;
428
429}   // end hal_fpu_context_alloc()
430
431//////////////////////////////////////////////
432void hal_fpu_context_init( thread_t * thread )
433{
434    hal_fpu_context_t * context = thread->fpu_context;
435
436    assert( (context != NULL) , "fpu context not allocated" );
437
438    memset( context , 0 , sizeof(hal_fpu_context_t) );
439}
440
441//////////////////////////////////////////
442void hal_fpu_context_copy( thread_t * dst,
443                           thread_t * src )
444{
445    assert( (src != NULL) , "src thread pointer is NULL\n");
446    assert( (dst != NULL) , "dst thread pointer is NULL\n");
447
448    // get fpu context pointers
449    hal_fpu_context_t * src_context = src->fpu_context;
450    hal_fpu_context_t * dst_context = dst->fpu_context;
451
452    // copy CPU context from src to dst
453    memcpy( dst_context , src_context , sizeof(hal_fpu_context_t) );
454
455}  // end hal_fpu_context_copy()
456
457/////////////////////////////////////////////////
458void hal_fpu_context_destroy( thread_t * thread )
459{
460    kmem_req_t  req;
461
462    hal_fpu_context_t * context = thread->fpu_context;
463
464    // release FPU context if required
465    if( context != NULL )
466    {   
467        req.type = KMEM_KCM;
468        req.ptr  = context;
469        kmem_free( &req );
470    }
471
472}  // end hal_fpu_context_destroy()
473
474//////////////////////////////////////////////
475void hal_fpu_context_save( xptr_t  thread_xp )
476{
477    // allocate a local FPU context in kernel stack
478    hal_fpu_context_t  src_context;
479
480    // get remote child cluster and local pointer
481    cxy_t      thread_cxy = GET_CXY( thread_xp );
482    thread_t * thread_ptr = GET_PTR( thread_xp );
483
484    asm volatile(
485    ".set noreorder           \n"
486    "swc1    $f0,    0*4(%0)  \n"   
487    "swc1    $f1,    1*4(%0)  \n"   
488    "swc1    $f2,    2*4(%0)  \n"   
489    "swc1    $f3,    3*4(%0)  \n"   
490    "swc1    $f4,    4*4(%0)  \n"   
491    "swc1    $f5,    5*4(%0)  \n"   
492    "swc1    $f6,    6*4(%0)  \n"   
493    "swc1    $f7,    7*4(%0)  \n"   
494    "swc1    $f8,    8*4(%0)  \n"   
495    "swc1    $f9,    9*4(%0)  \n"   
496    "swc1    $f10,  10*4(%0)  \n"   
497    "swc1    $f11,  11*4(%0)  \n"   
498    "swc1    $f12,  12*4(%0)  \n"   
499    "swc1    $f13,  13*4(%0)  \n"   
500    "swc1    $f14,  14*4(%0)  \n"   
501    "swc1    $f15,  15*4(%0)  \n"   
502    "swc1    $f16,  16*4(%0)  \n"   
503    "swc1    $f17,  17*4(%0)  \n"   
504    "swc1    $f18,  18*4(%0)  \n"   
505    "swc1    $f19,  19*4(%0)  \n"   
506    "swc1    $f20,  20*4(%0)  \n"   
507    "swc1    $f21,  21*4(%0)  \n"   
508    "swc1    $f22,  22*4(%0)  \n"   
509    "swc1    $f23,  23*4(%0)  \n"   
510    "swc1    $f24,  24*4(%0)  \n"   
511    "swc1    $f25,  25*4(%0)  \n"   
512    "swc1    $f26,  26*4(%0)  \n"   
513    "swc1    $f27,  27*4(%0)  \n"   
514    "swc1    $f28,  28*4(%0)  \n"   
515    "swc1    $f29,  29*4(%0)  \n"   
516    "swc1    $f30,  30*4(%0)  \n"   
517    "swc1    $f31,  31*4(%0)  \n"   
518    ".set reorder             \n"
519    : : "r"(&src_context) );
520
521    // get local pointer on target thread FPU context
522    void * dst_context = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->fpu_context ) );
523
524    // copy local context to remote child context)
525    hal_remote_memcpy( XPTR( thread_cxy , dst_context ),
526                       XPTR( local_cxy  , &src_context ), 
527                       sizeof( hal_fpu_context_t ) );
528
529}  // end hal_fpu_context_save()
530
531/////////////////////////////////////////////////
532void hal_fpu_context_restore( thread_t * thread )
533{
534    // get pointer on FPU context and cast to uint32_t
535    uint32_t ctx = (uint32_t)thread->fpu_context;
536
537    asm volatile(
538    ".set noreorder           \n"
539    "lwc1    $f0,    0*4(%0)  \n"   
540    "lwc1    $f1,    1*4(%0)  \n"   
541    "lwc1    $f2,    2*4(%0)  \n"   
542    "lwc1    $f3,    3*4(%0)  \n"   
543    "lwc1    $f4,    4*4(%0)  \n"   
544    "lwc1    $f5,    5*4(%0)  \n"   
545    "lwc1    $f6,    6*4(%0)  \n"   
546    "lwc1    $f7,    7*4(%0)  \n"   
547    "lwc1    $f8,    8*4(%0)  \n"   
548    "lwc1    $f9,    9*4(%0)  \n"   
549    "lwc1    $f10,  10*4(%0)  \n"   
550    "lwc1    $f11,  11*4(%0)  \n"   
551    "lwc1    $f12,  12*4(%0)  \n"   
552    "lwc1    $f13,  13*4(%0)  \n"   
553    "lwc1    $f14,  14*4(%0)  \n"   
554    "lwc1    $f15,  15*4(%0)  \n"   
555    "lwc1    $f16,  16*4(%0)  \n"   
556    "lwc1    $f17,  17*4(%0)  \n"   
557    "lwc1    $f18,  18*4(%0)  \n"   
558    "lwc1    $f19,  19*4(%0)  \n"   
559    "lwc1    $f20,  20*4(%0)  \n"   
560    "lwc1    $f21,  21*4(%0)  \n"   
561    "lwc1    $f22,  22*4(%0)  \n"   
562    "lwc1    $f23,  23*4(%0)  \n"   
563    "lwc1    $f24,  24*4(%0)  \n"   
564    "lwc1    $f25,  25*4(%0)  \n"   
565    "lwc1    $f26,  26*4(%0)  \n"   
566    "lwc1    $f27,  27*4(%0)  \n"   
567    "lwc1    $f28,  28*4(%0)  \n"   
568    "lwc1    $f29,  29*4(%0)  \n"   
569    "lwc1    $f30,  30*4(%0)  \n"   
570    "lwc1    $f31,  31*4(%0)  \n"   
571    ".set reorder             \n"
572    : : "r"(ctx) );
573
574} // end hal_cpu_context_restore()
575
576
Note: See TracBrowser for help on using the repository browser.