SYMBOL *gen_mp_virtual_thunk(SYMBOL *vsp)
{
QUAD *oi = intermed_head, *ot = intermed_tail;
LIST *v = mpthunklist;
SYMBOL *sp;
IMODE *ap1, *ap2;
char buf[256];
while (v)
{
sp = (SYMBOL*)v->data;
if (sp->value.i == vsp->value.classdata.vtabindex)
if (isstructured(vsp->tp->btp) == isstructured(sp->tp->btp))
return sp;
v = v->link;
}
intermed_head = intermed_tail = NULL;
blockMax = 0;
blockCount = tempCount = 0;
exitBlock = 0;
IncGlobalFlag();
sp = Alloc(sizeof(SYMBOL));
sp->storage_class = sc_static;
sp->tp = vsp->tp;
sp->value.i = vsp->value.classdata.vtabindex;
//sprintf(buf, "@$mpt$%d$%d", sp->value.i, isstructured(sp->tp->btp));
sp->name = sp->decoratedName = litlate(buf);
sp->errname = sp->decoratedName;
sp->staticlabel = FALSE;
sp->gennedvirtfunc = TRUE;
v = (LIST *)Alloc(sizeof(LIST));
v->data = sp;
v->link = mpthunklist;
mpthunklist = v;
DecGlobalFlag();
gen_virtual(sp, FALSE);
addblock(i_goto);
gen_icode(i_substack, NULL, ap2 = tempreg(ISZ_ADDR, 0), NULL);
gen_icode(i_add, ap2, ap2 , make_immed(ISZ_NONE, isstructured(sp->tp->btp) ? ISZ_ADDR * 2 : ISZ_ADDR));
ap1 = indnode(ap2, ISZ_ADDR);
gen_icode(i_assn, ap2 = tempreg(ISZ_ADDR, 0), ap1, 0);
if (sp->value.classdata.baseofs)
gen_icode(i_add, ap2, ap2, make_immed(ISZ_NONE, sp->value.classdata.baseofs));
ap1 = indnode(ap2, ISZ_ADDR);
gen_icode(i_assn, ap2 = tempreg(ISZ_ADDR, 0), ap1, 0);
gen_icode(i_add, ap2, ap2, make_immed(ISZ_NONE, sp->value.i));
ap1 = indnode(ap2, ISZ_ADDR);
gen_icode(i_directbranch, 0, ap1, 0);
addblock(i_ret);
optimize();
rewrite_icode(); /* Translate to machine code & dump */
if (chosenAssembler->gen->post_function_gen)
chosenAssembler->gen->post_function_gen(intermed_head);
gen_endvirtual(sp);
intermed_head = oi;
intermed_tail = ot;
return sp;
}
/*
* NAME: shift()
* DESCRIPTION: shift a line left or right
*/
static void shift(const char *text)
{
cmdbuf *cb;
int idx;
cb = ccb;
/* first determine the number of leading spaces */
idx = 0;
while (*text == ' ' || *text == HT) {
if (*text++ == ' ') {
idx++;
} else {
idx = (idx + 8) & ~7;
}
}
if (*text == '\0') {
/* don't shift lines with ws only */
addblock(cb, text);
cb->lineno++;
} else {
idx += cb->shift;
if (idx < MAX_LINE_SIZE) {
char buffer[MAX_LINE_SIZE];
char *p;
p = buffer;
/* fill with leading ws */
while (idx >= 8) {
*p++ = HT;
idx -= 8;
}
while (idx > 0) {
*p++ = ' ';
--idx;
}
if (p - buffer + strlen(text) < MAX_LINE_SIZE) {
strcpy(p, text);
addblock(cb, buffer);
cb->lineno++;
return;
}
}
/* Error: line too long. Finish block of lines already shifted. */
cb->last = cb->lineno;
endblock(cb);
error("Result of shift would be too long");
}
}
int eIOBuffer::fromfile(int fd, int len)
{
int re=0;
while (len)
{
int tc=len;
int r=0;
if (buffer.empty() || (allocationsize == buffer.back().len))
addblock();
if (tc > allocationsize-buffer.back().len)
tc=allocationsize-buffer.back().len;
r=::read(fd, buffer.back().data+buffer.back().len, tc);
buffer.back().len+=r;
if (r < 0)
{
if (errno != EWOULDBLOCK && errno != EBUSY && errno != EINTR)
eDebug("couldn't read: %m");
}
else
{
len-=r;
re+=r;
if (r != tc)
break;
}
}
return re;
}
int main()
{
// block : current block, block_prev: previous block header
block_type block;
block_header block_prev;
//va chercher le prvious block header dans la db
export_bloc("../database",&block_prev);
//rempli le block avec les info du header precedent
block.version=block_prev.version;
// test pour le 2eme bloc
// block.timestamp=1231469665;
// hash_digest merkl{0x0e,0x3e,0x23,0x57,0xe8,0x06,0xb6,0xcd,0xb1,0xf7,0x0b,0x54,0xc3,0xa3,0xa1,0x7b,0x67,0x14,0xee,0x1f,0x0e,0x68,0xbe,0xbb,0x44,0xa7,0x4b,0x1e,0xfd,0x51,0x20,0x98};
// block.nonce=2573394688;
// block.merkle=merkl;
block.previous_block_hash = calcul_hash(block_prev);
// Ici calcul_hash va etre la fonction couteuse en temps de calcul
block.merkle=generate_sha256_hash(uncast_type(block.previous_block_hash));
block.timestamp=block_prev.timestamp;
block.bits=block_prev.bits;
block.nonce=0;
// une fois toutes les info prisent, on peut inserer le block dans la db
return addblock("../database", block);
}
int main(int argc, char* argv[])
{
diy::mpi::environment env(argc, argv); // diy equivalent of MPI_Init
diy::mpi::communicator world; // diy equivalent of MPI communicator
int size = 8; // total number of MPI processes
int nblocks = 32; // total number of blocks in global domain
diy::ContiguousAssigner assigner(size, nblocks);
Bounds domain; // global data size
domain.min[0] = domain.min[1] = domain.min[2] = 0;
domain.max[0] = domain.max[1] = domain.max[2] = 255;
int rank = world.rank(); // MPI rank of this process
std::cout << "Rank " << rank << ":" << std::endl;
diy::Master master(world,
1, // one thread
-1, // all blocks in memory
&Block::create,
&Block::destroy);
AddBlock addblock(master); // object for adding new blocks to master
// share_face is an n-dim (size 3 in this example) vector of bools
// indicating whether faces are shared in each dimension
// uninitialized values default to false
diy::RegularDecomposer<Bounds>::BoolVector share_face;
share_face.push_back(true);
// wrap is an n-dim (size 3 in this example) vector of bools
// indicating whether boundary conditions are periodic in each dimension
// uninitialized values default to false
diy::RegularDecomposer<Bounds>::BoolVector wrap;
wrap.push_back(true);
wrap.push_back(true);
// ghosts is an n-dim (size 3 in this example) vector of ints
// indicating number of ghost cells per side in each dimension
// uninitialized values default to 0
diy::RegularDecomposer<Bounds>::CoordinateVector ghosts;
ghosts.push_back(1); ghosts.push_back(2);
// either create the regular decomposer and call its decompose function
// (having the decomposer available is useful for its other member functions
diy::RegularDecomposer<Bounds> decomposer(3,
domain,
assigner,
share_face,
wrap,
ghosts);
decomposer.decompose(rank, addblock);
// or combine the two lines above into the following helper function
// but the decomposer gets destroyed afterwards
// diy::decompose(3, rank, domain, assigner, addblock, share_face, wrap, ghosts);
// display the decomposition
master.foreach(&Block::show_link);
}
SYMBOL *gen_vsn_virtual_thunk(SYMBOL *func, int ofs)
{
QUAD *oi = intermed_head, *ot = intermed_tail;
SYMBOL *sp;
IMODE *ap1, *ap2;
char buf[256];
//sprintf(buf, "@$vsn%s$%d", func->decoratedName, ofs);
sp = search(buf, gsyms);
if (sp)
return sp;
intermed_head = intermed_tail = NULL;
blockMax = 0;
blockCount = tempCount = 0;
exitBlock = 0;
IncGlobalFlag();
sp = Alloc(sizeof(SYMBOL));
sp->storage_class = sc_static;
sp->value.i = ofs;
sp->name = sp->decoratedName = litlate(buf);
sp->errname = sp->decoratedName;
sp->staticlabel = FALSE;
sp->tp = func->tp;
sp->gennedvirtfunc = TRUE;
insert(sp, gsyms);
DecGlobalFlag();
gen_virtual(sp, FALSE);
addblock(i_goto);
gen_icode(i_substack, NULL, ap2 = tempreg(ISZ_ADDR, 0), NULL );
gen_icode(i_add, ap1 = tempreg(ISZ_ADDR, 0), ap2, make_immed(ISZ_NONE, getSize(bt_pointer)));
ap1 = indnode(ap1, ISZ_ADDR);
gen_icode(i_add, ap1, ap1 , make_immed(ISZ_NONE, - ofs));
ap1 = make_imaddress(varNode(en_napccon, func), ISZ_ADDR);
gen_icode(i_directbranch, 0, ap1, 0);
addblock(i_ret);
optimize();
rewrite_icode(); /* Translate to machine code & dump */
if (chosenAssembler->gen->post_function_gen)
chosenAssembler->gen->post_function_gen(intermed_head);
gen_endvirtual(sp);
intermed_head = oi;
intermed_tail = ot;
return sp;
}
void eIOBuffer::write(const void *source, int len)
{
const __u8 *src=(const __u8*)source;
while (len)
{
int tc=len;
if (buffer.empty() || (allocationsize == buffer.back().len))
addblock();
if (tc > allocationsize-buffer.back().len)
tc=allocationsize-buffer.back().len;
memcpy(buffer.back().data+buffer.back().len, src, tc);
src+=tc;
buffer.back().len+=tc;
len-=tc;
}
}
/*
* NAME: cmdbuf->join()
* DESCRIPTION: join a range of lines in the edit buffer
*/
int cb_join(cmdbuf *cb)
{
char buf[MAX_LINE_SIZE + 1];
Int *m;
if (cb->edbuf->lines == 0) {
error("No lines in buffer");
}
if (cb->first < 0) {
cb->first = cb->cthis;
}
if (cb->last < 0) {
cb->last = (cb->first == cb->edbuf->lines) ? cb->first : cb->first + 1;
}
cb_do(cb, cb->first);
cb->cthis = cb->othis = cb->first;
buf[0] = '\0';
cb->buffer = buf;
cb->buflen = 0;
eb_range(cb->edbuf, cb->first, cb->last, join, FALSE);
/* erase marks for joined lines */
for (m = cb->mark; m < &cb->mark[26]; m++) {
if (*m > cb->first && *m <= cb->last) {
*m = 0;
}
}
cb->flags |= CB_CHANGE;
startblock(cb);
addblock(cb, buf);
endblock(cb);
return RET_FLAGS;
}
void genfunc(SYMBOL *funcsp)
/*
* generate a function body and dump the icode
*/
{
IMODE *allocaAP = NULL;
SYMBOL *oldCurrentFunc;
EXPRESSION *funcexp = varNode(en_global, funcsp);
if (total_errors)
return;
// //printf("%s\n", funcsp->name);
contlab = breaklab = - 1;
structret_imode = 0 ;
tempCount = 0;
blockCount = 0;
blockMax = 0;
exitBlock = 0;
oldCurrentFunc = theCurrentFunc;
theCurrentFunc = funcsp;
iexpr_func_init();
/* firstlabel = nextLabel;*/
cseg();
gen_line(funcsp->linedata);
gen_func(funcexp, 1);
/* in C99 inlines can clash if declared 'extern' in multiple modules */
/* in C++ we introduce virtual functions that get coalesced at link time */
if (cparams.prm_cplusplus && funcsp->linkage == lk_inline)
gen_virtual(funcsp, FALSE);
else
{
if (funcsp->storage_class == sc_global)
globaldef(funcsp);
else
localdef(funcsp);
gen_strlab(funcsp); /* name of function */
}
addblock( - 1);
if (funcsp->linkage == lk_interrupt || funcsp->linkage == lk_fault) {
gen_icode(i_pushcontext, 0,0,0);
/* if (funcsp->loadds) */
/* gen_icode(i_loadcontext, 0,0,0); */
}
gen_icode(i_prologue,0,0,0);
gen_label(startlab);
/* if (funcsp->loadds && funcsp->farproc) */
/* gen_icode(i_loadcontext, 0,0,0); */
AllocateLocalContext(NULL, funcsp);
if (funcsp->allocaUsed)
{
EXPRESSION *allocaExp = varNode(en_auto, anonymousVar(sc_auto, &stdpointer));
allocaAP = gen_expr(funcsp, allocaExp, 0, ISZ_ADDR);
gen_icode(i_savestack, 0, allocaAP, 0);
}
/* Generate the icode */
/* LCSE is done while code is generated */
genstmt(funcsp->inlineFunc.stmt->lower, funcsp);
if (funcsp->inlineFunc.stmt->blockTail)
{
gen_icode(i_functailstart, 0, 0, 0);
genstmt(funcsp->inlineFunc.stmt->blockTail, funcsp);
gen_icode(i_functailend, 0, 0, 0);
}
genreturn(0, funcsp, 1, 0, allocaAP);
gen_func(funcexp, 0);
tFree();
InsertParameterThunks(funcsp, blockArray[1]);
optimize(funcsp);
FreeLocalContext(NULL, funcsp);
AllocateStackSpace(funcsp);
FillInPrologue(intermed_head, funcsp);
/* Code gen from icode */
rewrite_icode(); /* Translate to machine code & dump */
if (chosenAssembler->gen->post_function_gen)
chosenAssembler->gen->post_function_gen(funcsp, intermed_head);
if (cparams.prm_cplusplus && funcsp->linkage == lk_inline)
gen_endvirtual(funcsp);
intermed_head = NULL;
dag_rundown();
oFree();
theCurrentFunc = oldCurrentFunc;
if (blockCount > maxBlocks)
maxBlocks = blockCount;
if (tempCount > maxTemps)
maxTemps = tempCount;
}
void
bufinsert(Buffer *b, uint q0, Rune *s, uint n)
{
uint i, m, t, off;
if(q0 > b->nc)
panic("internal error: bufinsert");
while(n > 0){
setcache(b, q0);
off = q0-b->cq;
if(b->cnc+n <= Maxblock){
/* Everything fits in one block. */
t = b->cnc+n;
m = n;
if(b->bl == nil){ /* allocate */
if(b->cnc != 0)
panic("internal error: bufinsert1 cnc!=0");
addblock(b, 0, t);
b->cbi = 0;
}
sizecache(b, t);
runemove(b->c+off+m, b->c+off, b->cnc-off);
runemove(b->c+off, s, m);
b->cnc = t;
goto Tail;
}
/*
* We must make a new block. If q0 is at
* the very beginning or end of this block,
* just make a new block and fill it.
*/
if(q0==b->cq || q0==b->cq+b->cnc){
if(b->cdirty)
flush(b);
m = min(n, Maxblock);
if(b->bl == nil){ /* allocate */
if(b->cnc != 0)
panic("internal error: bufinsert2 cnc!=0");
i = 0;
}else{
i = b->cbi;
if(q0 > b->cq)
i++;
}
addblock(b, i, m);
sizecache(b, m);
runemove(b->c, s, m);
b->cq = q0;
b->cbi = i;
b->cnc = m;
goto Tail;
}
/*
* Split the block; cut off the right side and
* let go of it.
*/
m = b->cnc-off;
if(m > 0){
i = b->cbi+1;
addblock(b, i, m);
diskwrite(disk, &b->bl[i], b->c+off, m);
b->cnc -= m;
}
/*
* Now at end of block. Take as much input
* as possible and tack it on end of block.
*/
m = min(n, Maxblock-b->cnc);
sizecache(b, b->cnc+m);
runemove(b->c+b->cnc, s, m);
b->cnc += m;
Tail:
b->nc += m;
q0 += m;
s += m;
n -= m;
b->cdirty = TRUE;
}
}
/*
* NAME: subst()
* DESCRIPTION: do substitutions in a line. If something is substituted on line
* N, and the next substitution happens on line N + 2, line N + 1
* is joined in the new block also.
*/
static void subst(const char *text)
{
char line[MAX_LINE_SIZE];
cmdbuf *cb;
int idx, size;
char *p;
Int *k, *l;
Int newlines;
bool found;
cb = ccb;
found = FALSE;
newlines = 0;
idx = 0;
/*
* Because the write buffer might be flushed, and the text would
* not remain in memory, use a local copy.
*/
text = strcpy(line, text);
while (rx_exec(cb->regexp, text, idx, IGNORECASE(cb->vars)) > 0) {
if (cb->flags & CB_SKIPPED) {
/*
* add the previous line, in which nothing was substituted, to
* the block. Has to be done here, before the contents of the buffer
* are changed.
*/
addblock(cb, cb->buffer);
cb->flags &= ~CB_SKIPPED;
/*
* check if there were newlines in the last substitution. If there
* are, marks on the previous line (without substitutions) will
* also have to be changed.
*/
if (cb->offset > 0) {
for (k = cb->mark, l = cb->moffset; k < &cb->mark[26]; k++, l++)
{
if (*k == cb->lineno - 1 && *l == 0) {
*l = *k + cb->offset;
}
}
}
}
found = TRUE;
cb->flags &= ~(CB_UPPER | CB_LOWER | CB_TUPPER | CB_TLOWER);
size = cb->regexp->start - text - idx;
if (size > 0) {
/* copy first unchanged part of line to buffer */
sub(cb, text + idx, size);
}
p = cb->replace;
while (*p != '\0') {
switch (*p) {
case '&':
/* insert matching string */
sub(cb, cb->regexp->start, cb->regexp->size);
break;
case '\\': /* special substitute characters */
switch (*++p) {
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
/* insert subexpression between \( \) */
if (cb->regexp->se[*p - '1'].start != (char*) NULL) {
sub(cb, cb->regexp->se[*p - '1'].start,
cb->regexp->se[*p - '1'].size);
break;
}
/* if no subexpression, fall though */
default:
sub(cb, p, 1); /* ignore preceding backslash */
break;
case 'n':
cb->buffer[cb->buflen++] = '\0';
newlines++; /* insert newline */
break;
case 'U':
/* convert string to uppercase */
cb->flags |= CB_UPPER;
cb->flags &= ~(CB_LOWER | CB_TUPPER | CB_TLOWER);
break;
case 'L':
/* convert string to lowercase */
cb->flags |= CB_LOWER;
cb->flags &= ~(CB_UPPER | CB_TUPPER | CB_TLOWER);
break;
case 'e':
case 'E':
/* end case conversion */
cb->flags &= ~(CB_UPPER | CB_LOWER | CB_TUPPER | CB_TLOWER);
break;
case 'u':
/* convert char to uppercase */
cb->flags |= CB_TUPPER;
cb->flags &= ~CB_TLOWER;
break;
case 'l':
/* convert char to lowercase */
cb->flags &= ~CB_TUPPER;
cb->flags |= CB_TLOWER;
break;
case '\0': /* sigh */
continue;
}
break;
default: /* normal char */
sub(cb, p, 1);
break;
}
p++;
}
idx = cb->regexp->start + cb->regexp->size - text;
if (!(cb->flags & CB_GLOBSUBST) || text[idx] == '\0' ||
(cb->regexp->size == 0 && text[++idx] == '\0')) {
break;
}
}
if (found) {
if (text[idx] != '\0') {
/* concatenate unchanged part of line after found pattern */
cb->flags &= ~(CB_UPPER | CB_LOWER | CB_TUPPER | CB_TLOWER);
sub(cb, text + idx, strlen(text + idx));
}
if (!(cb->flags & CB_CURRENTBLK)) {
/* start a new block of lines with substitutions in them */
cb->flags |= CB_CHANGE;
cb->first = cb->lineno;
startblock(cb);
cb->flags |= CB_CURRENTBLK;
}
/* add this changed line to block */
cb->buffer[cb->buflen] = '\0';
if (newlines == 0) {
addblock(cb, cb->buffer);
} else {
/*
* There were newlines in the substituted string. Add all
* lines to the current block, and save the marks in range.
*/
p = cb->buffer;
do {
addblock(cb, p);
p += strlen(p) + 1;
} while (p <= cb->buffer + cb->buflen);
for (k = cb->mark, l = cb->moffset; k < &cb->mark[26]; k++, l++) {
if (*k == cb->lineno && *l == 0) {
*l = *k + cb->offset;
}
}
cb->offset += newlines;
}
cb->buflen = 0;
cb->last = cb->lineno;
} else {
if (cb->flags & CB_SKIPPED) {
/* two lines without substitutions now. Finish previous block. */
endblock(cb);
cb->lineno += cb->offset;
cb->offset = 0;
cb->flags &= ~(CB_CURRENTBLK | CB_SKIPPED);
} else if (cb->flags & CB_CURRENTBLK) {
/*
* no substitution on this line, but there was one on the previous
* line. mark this line as skipped, so it can still be added to
* the block of changed lines if the next line has substitutions.
*/
strcpy(cb->buffer, text);
cb->flags |= CB_SKIPPED;
}
}
cb->lineno++;
}
/*
* NAME: noshift()
* DESCRIPTION: add this line to the current block without shifting it
*/
static void noshift(cmdbuf *cb, const char *text)
{
addblock(cb, text);
cb->lineno++;
}
