lime.h

Go to the documentation of this file.

/* =============
 * apeNEXT/nlibc
 * =============
 *
 * $Id: lime.h,v 1.1 2006/06/08 14:15:05 pleiter Exp $
 * -------------------------------------------------------------------------- */

#ifndef _NLIBC_OS1_LIME_H
#define _NLIBC_OS1_LIME_H

#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>

#pragma PRAGMA_SW_REQ os opt-type ne 3

typedef struct {
  uint64_t ctrl;                
  uint64_t nbytes;              
  uint64_t vector type[9];      
} LimeRecordHeader;

typedef struct {
  FILE *fp;
  LimeRecordHeader *hdr;
} LimeReader;

typedef struct {
  FILE *fp;
  LimeRecordHeader *hdr;
} LimeWriter;

#define LIME_MAGIC_NO           1164413355      
#define LIME_VERSION            1               

#define LIME_SUCCESS            0               
#define LIME_ERR_PARAM          1               
#define LIME_ERR_HEADER_NEXT    2               
#define LIME_ERR_WRITE          3               
#define LIME_EOR                4               
#define LIME_EOF                5               
#define LIME_ERR_READ           6               
#define LIME_ERR_SEEK           7               
#define LIME_ERR_MBME           8               
#define LIME_ERR_CLOSE          9               


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern LimeReader* limeCreateReader(FILE *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeCreateReader_lime_h)
LimeReader* limeCreateReader(FILE *fp)
{
  LimeReader *r;

  if (!fp || !fp->fd) {
    errno = EBADF;
    return NULL;
  }

  r = (LimeReader*) malloc(sizeof(LimeReader));

  if (r == NULL)
    return NULL;

  r->fp = fp;
  r->hdr = NULL;

  asm("\t$lime_create($SYS_LIMEFLG_RD, 0.%0)\n" : : "r" (fp->fd));

  return r;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern void limeDestroyReader(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeDestroyReader_lime_h)
void limeDestroyReader(LimeReader *r)
{
  if (r != NULL) {
    asm("\t$lime_destroy($SYS_LIMEFLG_RD, 0.%0)\n" : : "r" (r->fp->fd));
    free(r);
    r = NULL;
  }
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeReaderNextRecord(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderNextRecord_lime_h)
int limeReaderNextRecord(LimeReader *r)
{
  vector int sys_rval;

  if (r == NULL || r->fp == NULL) {
    return LIME_EOF;
  }

  // Allocate memory if necessary
  if (r->hdr == NULL) {
    r->hdr = (LimeRecordHeader*) malloc(sizeof(LimeRecordHeader));
  }

  // Perform system service
  asm("\t$io_start\n"
      "\t$io_fd(0.%1)\n"
      "\t\\equl $cmd   $SYS_IOCMD_LIME_HRD\n"
      "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
      "\t\\equl $dev   $SYS_IODEV_MEM\n"
      "\t\\equl $l     $SYS_LIME_HDRLEN\n"
      "\t\\equl $bs    $SYS_IOBS_V\n"
      "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
      "\t\\equl $addr  0.%2\n"
      "\t$io_packet($cmd, $fmt, $rdflg, $dev, $l, $bs, $addr)\n"
      "\t$io_end\n"
      "\tlmtr %0 $MEM_SYS_RVAL\n"
      : "=r" (sys_rval) : "r" (r->fp->fd), "r" (r->hdr));

  return (int) sys_rval.lo;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeReaderMBFlag(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderMBFlag_lime_h)
int limeReaderMBFlag(LimeReader *r)
{
  int mbflg = -1;

  where (r != NULL && r->hdr != NULL) {
    mbflg = (r->hdr->ctrl >> 47) & 0x1;
  }

  return mbflg;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeReaderMEFlag(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderMEFlag_lime_h)
int limeReaderMEFlag(LimeReader *r)
{
  int meflg = -1;

  where (r != NULL && r->hdr != NULL) {
    meflg = (r->hdr->ctrl >> 46) & 0x1;
  }

  return meflg;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern char* limeReaderType(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderType_lime_h)
char* limeReaderType(LimeReader *r)
{
  char* type = NULL;

  where (r != NULL && r->hdr != NULL) {
    type = (char*) &(r->hdr->type);
  }

  return type;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern uint64_t limeReaderBytes(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderBytes_lime_h)
uint64_t limeReaderBytes(LimeReader *r)
{
  int nbytes = -1;

  where (r != NULL && r->hdr != NULL) {
    nbytes = r->hdr->nbytes;
  }

  return nbytes;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern size_t limeReaderPadBytes(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderBytes_lime_h)
size_t limeReaderPadBytes(LimeReader *r)
{
  int npadbytes = -1;

  where (r != NULL && r->hdr != NULL) {
    npadbytes = (r->hdr->nbytes) % 8;
  }

  return npadbytes;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define limeReaderReadData(PTR, NMEMB, STREAM) \
        __limeReaderReadData(__typecode(*PTR), PTR, NMEMB, STREAM)

#ifndef __HAS_MAIN
extern int __limeReaderReadData(int, void *, uint64_t *, LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses___limeReaderReadData_lime_h)
int __limeReaderReadData(int tcode, void *dest, uint64_t *nbytes, LimeReader *r)
{
  int nword;
  vector int sys_rval;

  if (r == NULL || r->fp == NULL)
    return LIME_ERR_PARAM;

#define __iopacket(rdflg) \
    asm("\t$io_start\n" \
        "\t\\equl $cmd   $SYS_IOCMD_LIME_BRD\n" \
        "\t\\equl $fmt   $SYS_IOFMT_BIN\n" \
        "\t\\equl $sep   $SYS_IOPSEP_NOP\n" \
        "\t\\equl $rdflg %1\n" \
        "\t\\equl $dev   $SYS_IODEV_MEM\n" \
        "\t\\equl $l     0.%2\n" \
        "\t\\equl $bs    $SYS_IOBS_V\n" \
        "\t$io_fd( 0.%3 )\n" \
        "\t$io_slice_all\n" \
        "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%4)\n" \
        "\t$io_end\n" \
        "\tlmtr %0 $MEM_SYS_RVAL\n" \
        : "=r" (sys_rval) : "I" (rdflg), "r" (nword), "r" (r->fp->fd), "r" (dest))

  if ((tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE)) {
    nword = (*nbytes) >> 3;
    __iopacket(_SYS_IORDFLG_HZERO);
  }
  else if ((tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED)) {
    nword = (*nbytes) >> 3;
    __iopacket(_SYS_IORDFLG_HMIRROR);
  }
  else if ((tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) ||
           (tcode==NLCC_VINT) || (tcode==NLCC_VUINT)) { 
    nword = (*nbytes) >> 4;
    __iopacket(_SYS_IORDFLG_NOP);
  }
  else {
    assert(0);
  }
  (*nbytes) = (int) sys_rval.hi;

#undef __iopacket

  return (int) sys_rval.lo;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define limeReaderSliceReadData(X0, Y0, Z0, X1, Y1, Z1, PTR, NMEMB, STREAM) \
        __limeReaderSliceReadData(X0, Y0, Z0, X1, Y1, Z1, \
                                  __typecode(*PTR), PTR, NMEMB, STREAM)

#ifndef __HAS_MAIN
extern int __limeReaderSliceReadData(int, int, int, int, int, int,
                                     int, void *, uint64_t *, LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses___limeReaderSliceReadData_lime_h)
int __limeReaderSliceReadData(int x0, int y0, int z0, int x1, int y1, int z1,
                         int tcode, void *dest, uint64_t *nbytes, LimeReader *r)
{
  int nword;
  vector int sys_rval;

  if (r == NULL || r->fp == NULL)
    return LIME_ERR_READ;

#define __iopacket(rdflg) \
    asm("\t$io_start\n" \
        "\t\\equl $cmd   $SYS_IOCMD_LIME_MRD\n" \
        "\t\\equl $fmt   $SYS_IOFMT_BIN\n" \
        "\t\\equl $sep   $SYS_IOPSEP_NOP\n" \
        "\t\\equl $rdflg %0\n" \
        "\t\\equl $dev   $SYS_IODEV_MEM\n" \
        "\t\\equl $l     0.%1\n" \
        "\t\\equl $bs    $SYS_IOBS_V\n" \
        "\t$io_fd(0.%2)\n" \
        "\t$io_slice(0.%3,0.%4,0.%5,0.%6,0.%7,0.%8)\n" \
        "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%9)\n" \
        "\t$io_end\n" \
        :: "I" (rdflg), "r" (nword), "r" (r->fp->fd), \
           "r" (x0), "r" (y0), "r" (z0), \
           "r" (x1), "r" (y1), "r" (z1), \
           "r" (dest)); \
    asm("\tlmtr %0 $MEM_SYS_RVAL\n" : "=r" (sys_rval))

  if ((tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE)) {
    nword = (*nbytes) >> 3;
    __iopacket(_SYS_IORDFLG_HZERO);
  }
  else if ((tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED)) {
    nword = (*nbytes) >> 3;
    __iopacket(_SYS_IORDFLG_HMIRROR);
  }
  else if ((tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) ||
           (tcode==NLCC_VINT) || (tcode==NLCC_VUINT)) { 
    nword = (*nbytes) >> 4;
    __iopacket(_SYS_IORDFLG_NOP);
  }
  else {
    assert(0);
  }
  (*nbytes) = (int) sys_rval.hi;

#undef __iopacket

  return (int) sys_rval.lo;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeReaderCloseRecord(LimeReader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderCloseRecord_lime_h)
int limeReaderCloseRecord(LimeReader *r)
{
  if (r == NULL) {
    return LIME_ERR_SEEK;
  }

  // Perform system service
  asm("\t$lime_closerecord($SYS_LIMEFLG_RD, 0.%0)\n" : : "r" (r->fp->fd));

  return LIME_SUCCESS;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeReaderSeek(LimeReader *, off_t, int);
#else
#if !defined(__cflow_processed) || defined(_uses_limeReaderSeek_lime_h)
int limeReaderSeek(LimeReader *r, off_t offset, int whence)
{
  int sys_whence;

  if (r == NULL) {
    return LIME_ERR_SEEK;
  }

  sys_whence = -1;
  where (whence == SEEK_SET)
    asm("$sys_setwhence(%0, $SYS_FSE_SET)\n" : "=r" (sys_whence));
  where (whence == SEEK_CUR)
    asm("$sys_setwhence(%0, $SYS_FSE_CUR)\n" : "=r" (sys_whence));
  where (whence == SEEK_END)
    asm("$sys_setwhence(%0, $SYS_FSE_END)\n" : "=r" (sys_whence));
  if (sys_whence < 0) {
    errno = EINVAL;
    return LIME_ERR_SEEK;
  }

  // Perform system service
  asm("\t$lime_seek($SYS_LIMEFLG_RD, 0.%0, 0.%1, %2)\n"
      : :  "r" (r->fp->fd), "r" (offset), "r" (sys_whence));

  return LIME_SUCCESS;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern LimeWriter* limeCreateWriter(FILE *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeCreateWriter_lime_h)
LimeWriter* limeCreateWriter(FILE *fp)
{
  LimeWriter *w;

  if (!fp || !fp->fd) {
    errno = EBADF;
    return NULL;
  }

  w = (LimeWriter*) malloc(sizeof(LimeWriter));

  if (w == NULL)
    return NULL;

  w->fp = fp;
  w->hdr = NULL;

  asm("\t$lime_create($SYS_LIMEFLG_WR, 0.%0)\n" : : "r" (fp->fd));

  return w;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeDestroyWriter(LimeWriter *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeDestroyWriter_lime_h)
int limeDestroyWriter(LimeWriter *w)
{
  if (w != NULL) {
    asm("\t$lime_destroy($SYS_LIMEFLG_WR, 0.%0)\n" : : "r" (w->fp->fd));
    free(w);
    w = NULL;
    return LIME_SUCCESS;
  }
  else
    return 0;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeWriteRecordHeader(LimeRecordHeader *, LimeWriter *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeWriteRecordHeader_lime_h)
int limeWriteRecordHeader(LimeRecordHeader *h, LimeWriter* w)
{
  int ret = LIME_SUCCESS;
  vector int sys_rval;

  if (w == NULL || w->fp == NULL || h == NULL) {
    return LIME_ERR_PARAM;
  }

  w->hdr = h;

  // Perform system service
  asm("\t$io_start\n"
      "\t$io_fd(0.%1)\n"
      "\t\\equl $cmd   $SYS_IOCMD_LIME_HWR\n"
      "\t\\equl $fmt   $SYS_IOFMT_BIN\n"
      "\t\\equl $dev   $SYS_IODEV_MEM\n"
      "\t\\equl $l     $SYS_LIME_HDRLEN\n"
      "\t\\equl $bs    $SYS_IOBS_V\n"
      "\t\\equl $rdflg $SYS_IORDFLG_NOP\n"
      "\t\\equl $addr  0.%2\n"
      "\t$io_packet($cmd, $fmt, $rdflg, $dev, $l, $bs, $addr)\n"
      "\t$io_end\n"
      "\tlmtr %0 $MEM_SYS_RVAL\n"
      : "=r" (sys_rval) : "r" (w->fp->fd), "r" (h));

  where (sys_rval.lo) {
    ret = LIME_ERR_PARAM;
  }

  return ret;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeWriterCloseRecord(LimeWriter *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeWriterCloseRecord_lime_h)
int limeWriterCloseRecord(LimeWriter* w)
{
  if (w == NULL) {
    return LIME_ERR_SEEK;
  }

  // Perform system service
  asm("\t$lime_closerecord($SYS_LIMEFLG_WR, 0.%0)\n" : : "r" (w->fp->fd));

  return LIME_SUCCESS;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern int limeWriterSeek(LimeWriter *, off_t, int);
#else
#if !defined(__cflow_processed) || defined(_uses_limeWriterSeek_lime_h)
int limeWriterSeek(LimeWriter* w, off_t offset, int whence)
{
  int sys_whence;

  if (w == NULL) {
    return LIME_ERR_SEEK;
  }

  sys_whence = -1;
  where (whence == SEEK_SET)
    asm("$sys_setwhence(%0, $SYS_FSE_SET)\n" : "=r" (sys_whence));
  where (whence == SEEK_CUR)
    asm("$sys_setwhence(%0, $SYS_FSE_CUR)\n" : "=r" (sys_whence));
  where (whence == SEEK_END)
    asm("$sys_setwhence(%0, $SYS_FSE_END)\n" : "=r" (sys_whence));
  if (sys_whence < 0) {
    errno = EINVAL;
    return LIME_ERR_SEEK;
  }

  // Perform system service
  asm("\t$lime_seek($SYS_LIMEFLG_WR, 0.%0, 0.%1, %2)\n"
      : :  "r" (w->fp->fd), "r" (offset), "r" (sys_whence));

  return LIME_SUCCESS;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern LimeRecordHeader limeCreateHeader(int, int, char*, uint64_t);
#else
#if !defined(__cflow_processed) || defined(_uses_limeCreateHeader_lime_h)
LimeRecordHeader *limeCreateHeader(int MB_flag, int ME_flag, char *type,
                                   uint64_t rec_len)
{
  int i;
  LimeRecordHeader *h;

  h = (LimeRecordHeader *) malloc(sizeof(LimeReader));

  h->ctrl = ((LIME_MAGIC_NO & 0xffffffff))       |
            ((LIME_VERSION  & 0x000000ff) << 48) |
            ((MB_flag       & 0x00000001) << 47) |
            ((ME_flag       & 0x00000001) << 46);

  h->nbytes = rec_len;

  for (i = 0; i < 8; i++) {
    h->type[i] = *((uint64_t vector *) &type[i]);
    if ((uint64_t vector) type[i] == (uint64_t vector) 0)
      break;
  }
  for (; i < 9; i++)
    h->type[i] = 0;

  return h;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#ifndef __HAS_MAIN
extern void limeDestroyHeader(LimeRecordHeader *);
#else
#if !defined(__cflow_processed) || defined(_uses_limeDestroyHeader_lime_h)
void limeDestroyHeader(LimeRecordHeader *h)
{
  if (h != NULL)
    free(h);
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define limeWriteRecordData(PTR, NMEMB, STREAM) \
        __limeWriteRecordData(__typecode(*PTR), PTR, NMEMB, STREAM)

#ifndef __HAS_MAIN
extern int __limeWriteRecordData(void*, uint64_t*,  LimeWriter*);
#else
#if !defined(__cflow_processed) || defined(_uses___limeWriteRecordData_lime_h)
int __limeWriteRecordData(int tcode, void *source, uint64_t *nbytes,  LimeWriter* w)
{
  int nword;
  vector int sys_rval;

  if (w == NULL || w->fp == NULL)
    return LIME_ERR_PARAM;

#define __iopacket(bs) \
    asm("\t$io_start\n" \
        "\t\\equl $cmd   $SYS_IOCMD_LIME_GWR\n" \
        "\t\\equl $fmt   $SYS_IOFMT_BIN\n" \
        "\t\\equl $sep   $SYS_IOPSEP_NOP\n" \
        "\t\\equl $rdflg $SYS_IORDFLG_NOP\n" \
        "\t\\equl $dev   $SYS_IODEV_MEM\n" \
        "\t\\equl $l     0.%1\n" \
        "\t\\equl $bs    %2\n" \
        "\t$io_fd( 0.%3 )\n" \
        "\t$io_slice_all\n" \
        "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%4)\n" \
        "\t$io_end\n" \
        "\tlmtr %0 $MEM_SYS_RVAL\n" \
        : "=r" (sys_rval) : "r" (nword), "I" (bs), "r" (w->fp->fd), "r" (source))

  if ((tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE) ||
      (tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED)) {
    nword = (*nbytes) >> 3;
    __iopacket(_SYS_IOBS_L);
  }
  else if ((tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) ||
           (tcode==NLCC_VINT) || (tcode==NLCC_VUINT)) { 
    nword = (*nbytes) >> 4;
    __iopacket(_SYS_IOBS_V);
  }
  else {
    assert(0);
  }
  (*nbytes) = (int) sys_rval.hi;

#undef __iopacket

  return (int) sys_rval.lo;
}
#endif
#endif


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#define limeSliceWriteRecordData(X0, Y0, Z0, X1, Y1, Z1, PTR, NMEMB, STREAM) \
        __limeSliceWriteRecordData(X0, Y0, Z0, X1, Y1, Z1, \
                                   __typecode(*PTR), PTR, NMEMB, STREAM)

#ifndef __HAS_MAIN
extern int __limeSliceWriteRecordData(int, int, int, int, int, int,
                                      void*, uint64_t*,  LimeWriter*);
#else
#if !defined(__cflow_processed) || defined(_uses___limeSliceWriteRecordData_lime_h)
int __limeSliceWriteRecordData(int x0, int y0, int z0, int x1, int y1, int z1,
                               int tcode, void *source, uint64_t *nbytes,
                               LimeWriter* w)
{
  int nword;
  vector int sys_rval;

  if (w == NULL || w->fp == NULL)
    return LIME_ERR_WRITE;

#define __iopacket(bs) \
    asm("\t$io_start\n" \
        "\t\\equl $cmd   $SYS_IOCMD_LIME_SWR\n" \
        "\t\\equl $fmt   $SYS_IOFMT_BIN\n" \
        "\t\\equl $sep   $SYS_IOPSEP_NOP\n" \
        "\t\\equl $rdflg $SYS_IORDFLG_NOP\n" \
        "\t\\equl $dev   $SYS_IODEV_MEM\n" \
        "\t\\equl $l     0.%0\n" \
        "\t\\equl $bs    %1\n" \
        "\t$io_fd(0.%2)\n" \
        "\t$io_slice(0.%3,0.%4,0.%5,0.%6,0.%7,0.%8)\n" \
        "\t$io_packet($cmd, <$fmt .or. $sep>, $rdflg, $dev, $l, $bs, 0.%9)\n" \
        "\t$io_end\n" \
        "\tlmtr %0 $MEM_SYS_RVAL\n" \
        :: "r" (nword), "I" (bs), "r" (w->fp->fd), \
           "r" (x0), "r" (y0), "r" (z0), \
           "r" (x1), "r" (y1), "r" (z1), \
           "r" (source)); \
    asm("\tlmtr %0 $MEM_SYS_RVAL\n" : "=r" (sys_rval))

  if ((tcode==NLCC_FLOAT) || (tcode==NLCC_DOUBLE) ||
      (tcode==NLCC_INT) || (tcode==NLCC_UNSIGNED)) {
    nword = (*nbytes) >> 3;
    __iopacket(_SYS_IOBS_L);
  }
  else if ((tcode==NLCC_COMPLEX) || (tcode==NLCC_VECTOR) || (tcode==NLCC_VFLOAT) ||
           (tcode==NLCC_VINT) || (tcode==NLCC_VUINT)) { 
    nword = (*nbytes) >> 4;
    __iopacket(_SYS_IOBS_V);
  }
  else {
    assert(0);
  }
  (*nbytes) = (int) sys_rval.hi;

#undef __iopacket

  return (int) sys_rval.lo;
}
#endif
#endif

#endif /* _NLIBC_OS1_LIME_H */

---