/*
* destination buffer size
*/
size_t
_elf32_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
Elf_Type type = src->d_type;
unsigned sv = src->d_version;
xlator op;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return (size_t)-1;
}
if (tof) {
/*
* Encoding doesn't really matter (the translator only looks at
* the source, which resides in memory), but we need a proper
* encoding to select a translator...
*/
encode = ELFDATA2LSB;
}
else if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return (size_t)-1;
}
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
if (!(op = translator(sv, dv, encode, type, tof))) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
return (*op)(NULL, src->d_buf, src->d_size);
}
int MPI_Bcast_local(void *buffer, int count, MPI_Datatype datatype, int local_root, MPI_Comm comm)
{
assert(valid_type(datatype));
int ep_rank_loc = comm.ep_comm_ptr->size_rank_info[1].first;
::MPI_Aint datasize, lb;
::MPI_Type_get_extent(to_mpi_type(datatype), &lb, &datasize);
if(ep_rank_loc == local_root)
{
comm.my_buffer->void_buffer[local_root] = buffer;
}
MPI_Barrier_local(comm);
if(ep_rank_loc != local_root)
{
#pragma omp critical (_bcast)
memcpy(buffer, comm.my_buffer->void_buffer[local_root], datasize * count);
}
MPI_Barrier_local(comm);
}
/*
* Extension: report memory size
*/
size_t
gelf_msize(Elf *elf, Elf_Type type, size_t count, unsigned ver) {
size_t n;
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (!valid_class(elf->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
}
else if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _msize(elf->e_class, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
else {
return count * n;
}
}
return 0;
}
/*
* Extension: report memory size
*/
size_t
gcgcef_msize(CGCEf *cgcef, CGCEf_Type type, size_t count, unsigned ver) {
size_t n;
if (cgcef) {
if (cgcef->e_kind != CGCEF_K_CGCEF) {
seterr(ERROR_NOTCGCEF);
}
else if (!valid_class(cgcef->e_class)) {
seterr(ERROR_UNKNOWN_CLASS);
}
else if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _msize(cgcef->e_class, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
else {
return count * n;
}
}
return 0;
}
static yajl_gen_status
generate_key(yajl_gen g, Var v, void *ctx)
{
struct generate_context *gctx = (struct generate_context *)ctx;
switch (v.type) {
case TYPE_OBJ:
case TYPE_INT:
case TYPE_FLOAT:
case TYPE_ERR:
{
const char *tmp = value_to_literal(v);
if (MODE_EMBEDDED_TYPES == gctx->mode)
tmp = append_type(tmp, v.type);
return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp));
}
case TYPE_STR:
{
const char *tmp = v.v.str;
size_t len = strlen(tmp);
if (MODE_EMBEDDED_TYPES == gctx->mode)
if (TYPE_NONE != valid_type(&tmp, &len))
tmp = append_type(tmp, v.type);
return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp));
}
default:
panic("Unsupported type in generate_key()");
}
return yajl_gen_keys_must_be_strings;
}
int MPI_Gatherv_local(const void *sendbuf, int count, MPI_Datatype datatype, void *recvbuf, const int recvcounts[], const int displs[], int local_root, MPI_Comm comm)
{
assert(valid_type(datatype));
::MPI_Aint datasize, lb;
::MPI_Type_get_extent(to_mpi_type(datatype), &lb, &datasize);
int ep_rank_loc = comm.ep_comm_ptr->size_rank_info[1].first;
int num_ep = comm.ep_comm_ptr->size_rank_info[1].second;
#pragma omp critical (_gatherv)
comm.my_buffer->void_buffer[ep_rank_loc] = const_cast< void* >(sendbuf);
MPI_Barrier_local(comm);
if(ep_rank_loc == local_root)
{
for(int i=0; i<num_ep; i++)
memcpy(recvbuf + datasize*displs[i], comm.my_buffer->void_buffer[i], datasize*recvcounts[i]);
}
MPI_Barrier_local(comm);
}
static yajl_gen_status
generate(yajl_gen g, Var v, void *ctx)
{
struct generate_context *gctx = (struct generate_context *)ctx;
switch (v.type) {
case TYPE_INT:
return yajl_gen_integer(g, v.v.num);
case TYPE_FLOAT:
return yajl_gen_double(g, *v.v.fnum);
case TYPE_OBJ:
case TYPE_ERR:
{
const char *tmp = value_to_literal(v);
if (MODE_EMBEDDED_TYPES == gctx->mode)
tmp = append_type(tmp, v.type);
return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp));
}
case TYPE_STR:
{
const char *tmp = v.v.str;
size_t len = strlen(tmp);
if (MODE_EMBEDDED_TYPES == gctx->mode)
if (TYPE_NONE != valid_type(&tmp, &len))
tmp = append_type(tmp, v.type);
return yajl_gen_string(g, (const unsigned char *)tmp, strlen(tmp));
}
case TYPE_MAP:
{
struct do_map_closure dmc;
dmc.g = g;
dmc.gctx = gctx;
dmc.status = yajl_gen_status_ok;
yajl_gen_map_open(g);
if (mapforeach(v, do_map, &dmc))
return dmc.status;
yajl_gen_map_close(g);
return yajl_gen_status_ok;
}
case TYPE_LIST:
{
int i;
yajl_gen_status status;
yajl_gen_array_open(g);
for (i = 1; i <= v.v.list[0].v.num; i++) {
status = generate(g, v.v.list[i], ctx);
if (yajl_gen_status_ok != status)
return status;
}
yajl_gen_array_close(g);
return yajl_gen_status_ok;
}
default:
panic("Unsupported type in generate()");
}
return -1;
}
static char*
_elf_item(Elf *elf, Elf_Type type, size_t n, size_t off, int *flag) {
Elf_Data src, dst;
*flag = 0;
elf_assert(n);
elf_assert(valid_type(type));
if (off > elf->e_size) {
seterr(ERROR_OUTSIDE);
return NULL;
}
src.d_type = type;
src.d_version = elf->e_version;
src.d_size = n * _fsize(elf->e_class, src.d_version, type);
elf_assert(src.d_size);
if ((elf->e_size - off) < src.d_size) {
seterr(truncerr(type));
return NULL;
}
dst.d_version = _elf_version;
dst.d_size = n * _msize(elf->e_class, dst.d_version, type);
elf_assert(dst.d_size);
elf_assert(elf->e_data);
if (elf->e_rawdata != elf->e_data && dst.d_size <= src.d_size) {
dst.d_buf = elf->e_data + off;
}
else if (!(dst.d_buf = malloc(dst.d_size))) {
seterr(memerr(type));
return NULL;
}
else {
*flag = 1;
}
if (elf->e_rawdata) {
src.d_buf = elf->e_rawdata + off;
}
else {
src.d_buf = elf->e_data + off;
}
if (_elf_xlatetom(elf, &dst, &src)) {
if (!*flag) {
elf->e_cooked = 1;
}
return (char*)dst.d_buf;
}
if (*flag) {
free(dst.d_buf);
*flag = 0;
}
return NULL;
}
/*
* direction-independent translation
*/
static Elf_Data*
elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
Elf_Type type;
int dv;
int sv;
size_t dsize;
size_t tmp;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
op = translator(sv, dv, encode, type, tof);
if (!op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
dsize = (*op)(NULL, src->d_buf, src->d_size);
if (dsize == (size_t)-1) {
return NULL;
}
if (dst->d_size < dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (dsize) {
tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
if (tmp == (size_t)-1) {
return NULL;
}
elf_assert(tmp == dsize);
}
dst->d_size = dsize;
dst->d_type = type;
return dst;
}
double recent_time(timer_type type = TOTAL_TIME) const {
if (!valid_type(type)) throw std::runtime_error("stopwatch: invalid timer type");
if (!running) return 0;
switch (type) {
case WALL_TIME: return recent_wall_time();
case TOTAL_TIME: return recent_total_time();
case USER_TIME: return recent_user_time();
case SYSTEM_TIME: return recent_system_time();
case PAGEFAULTS: return recent_major_pagefaults();
default: throw std::runtime_error("bug-didn't handle timer type in stopwatch::recent_time");
}
}
int parse_path(const char * path, char ** type, char ** target, char ** name)
{
assert(path != NULL);
*type = *target = *name = NULL;
char * delim1 = strchr(path, ':');
char * delim2 = strrchr(path, ':');
if (delim1 == NULL && delim2 == NULL) { // <target>
if (asprintf(target, "%s", path) < 0) {
ERRNO(errno);
return -1;
}
} else if (delim1 == delim2) { // <target>:<name>
if (asprintf(target, "%.*s", (uint32_t)(delim1 - path), path) < 0) {
ERRNO(errno);
return -1;
}
delim1++;
if (asprintf(name, "%s", delim1) < 0) {
ERRNO(errno);
return -1;
}
if (valid_type(*target) == true) {
*type = *target;
*target = *name;
*name = NULL;
}
} else if (delim1 != delim2) { // <type>:<target>:<name>
if (asprintf(type, "%.*s", (uint32_t)(delim1 - path), path) < 0) {
ERRNO(errno);
return -1;
}
delim1++;
if (asprintf(target, "%.*s", (uint32_t)(delim2 - delim1), delim1) < 0) {
ERRNO(errno);
return -1;
}
delim2++;
if (asprintf(name, "%s", delim2) < 0) {
ERRNO(errno);
return -1;
}
}
return 0;
}
static size_t
_elf_fsize(unsigned cls, Elf_Type type, unsigned ver) {
size_t n = 0;
if (!valid_version(ver)) {
seterr(ERROR_UNKNOWN_VERSION);
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
else if (!(n = _fsize(cls, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
return n;
}
/*
* Checks:
* name not null and alphabetic
* valid type of variable
*
* Returns:
* <0 if there is an error
*
* NULL data is fine
*/
static int
check_table( const optionT * opt )
{ int i;
assert( opt );
for( i=0; opt[i].name && buffIsValid(opt[i].name) &&
valid_type(opt[i].type) && valid_flag(opt[i].flags) ; i++ )
;
if( opt[i].name == NULL )
return -i;
return check_colitions( opt );
}
/*
* direction-independent translation
*/
static Elf_Data*
elf32_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
size_t ssize, dsize, count;
Elf_Type type;
int sv, dv;
xlator op;
if (!src || !dst) {
return NULL;
}
if (!src->d_buf || !dst->d_buf) {
seterr(ERROR_NULLBUF);
return NULL;
}
if (!valid_encoding(encode)) {
seterr(ERROR_UNKNOWN_ENCODING);
return NULL;
}
sv = src->d_version;
dv = dst->d_version;
if (!valid_version(sv) || !valid_version(dv)) {
seterr(ERROR_UNKNOWN_VERSION);
return NULL;
}
type = src->d_type;
if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
ssize = _fmsize(ELFCLASS32, sv, type, 1 - tof);
dsize = _fmsize(ELFCLASS32, dv, type, tof);
op = translator(sv, dv, encode, type, tof);
if (!ssize || !dsize || !op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
count = src->d_size / ssize;
if (dst->d_size < count * dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (count) {
(*op)(dst->d_buf, src->d_buf, count);
}
dst->d_size = count * dsize;
dst->d_type = type;
return dst;
}
static char*
_elf_item(void *buf, Elf *elf, Elf_Type type, size_t off) {
Elf_Data src, dst;
elf_assert(valid_type(type));
if (off < 0 || off > elf->e_size) {
seterr(ERROR_OUTSIDE);
return NULL;
}
src.d_type = type;
src.d_version = elf->e_version;
src.d_size = _fsize(elf->e_class, src.d_version, type);
elf_assert(src.d_size);
if ((elf->e_size - off) < src.d_size) {
seterr(truncerr(type));
return NULL;
}
dst.d_version = _elf_version;
dst.d_size = _msize(elf->e_class, dst.d_version, type);
elf_assert(dst.d_size);
if (!(dst.d_buf = buf) && !(dst.d_buf = malloc(dst.d_size))) {
seterr(memerr(type));
return NULL;
}
elf_assert(elf->e_data);
if (elf->e_rawdata) {
src.d_buf = elf->e_rawdata + off;
}
else {
src.d_buf = elf->e_data + off;
}
if (_elf_xlatetom(elf, &dst, &src)) {
return (char*)dst.d_buf;
}
if (dst.d_buf != buf) {
free(dst.d_buf);
}
return NULL;
}
int MPI_Exscan(const void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
{
if(!comm.is_ep)
{
return ::MPI_Scan(sendbuf, recvbuf, count, to_mpi_type(datatype), to_mpi_op(op), to_mpi_comm(comm.mpi_comm));
}
valid_type(datatype);
int ep_rank = comm.ep_comm_ptr->size_rank_info[0].first;
int ep_rank_loc = comm.ep_comm_ptr->size_rank_info[1].first;
int mpi_rank = comm.ep_comm_ptr->size_rank_info[2].first;
int ep_size = comm.ep_comm_ptr->size_rank_info[0].second;
int num_ep = comm.ep_comm_ptr->size_rank_info[1].second;
int mpi_size = comm.ep_comm_ptr->size_rank_info[2].second;
::MPI_Aint datasize, lb;
::MPI_Type_get_extent(to_mpi_type(datatype), &lb, &datasize);
void* tmp_sendbuf;
tmp_sendbuf = new void*[datasize * count];
int my_src = 0;
int my_dst = ep_rank;
std::vector<int> my_map(mpi_size, 0);
for(int i=0; i<comm.rank_map->size(); i++) my_map[comm.rank_map->at(i).second]++;
for(int i=0; i<mpi_rank; i++) my_src += my_map[i];
my_src += ep_rank_loc;
for(int i=0; i<mpi_size; i++)
{
if(my_dst < my_map[i])
{
my_dst = get_ep_rank(comm, my_dst, i);
break;
}
else
my_dst -= my_map[i];
}
if(ep_rank != my_dst)
{
MPI_Request request[2];
MPI_Status status[2];
MPI_Isend(sendbuf, count, datatype, my_dst, my_dst, comm, &request[0]);
MPI_Irecv(tmp_sendbuf, count, datatype, my_src, ep_rank, comm, &request[1]);
MPI_Waitall(2, request, status);
}
else memcpy(tmp_sendbuf, sendbuf, datasize*count);
void* tmp_recvbuf;
tmp_recvbuf = new void*[datasize * count];
MPI_Reduce_local(tmp_sendbuf, tmp_recvbuf, count, datatype, op, 0, comm);
if(ep_rank_loc == 0)
::MPI_Exscan(MPI_IN_PLACE, tmp_recvbuf, count, to_mpi_type(datatype), to_mpi_op(op), to_mpi_comm(comm.mpi_comm));
// printf(" ID=%d : %d %d \n", ep_rank, static_cast<int*>(tmp_recvbuf)[0], static_cast<int*>(tmp_recvbuf)[1]);
MPI_Exscan_local(tmp_sendbuf, tmp_recvbuf, count, datatype, op, comm);
// printf(" ID=%d : after local tmp_sendbuf = %d %d ; tmp_recvbuf = %d %d \n", ep_rank, static_cast<int*>(tmp_sendbuf)[0], static_cast<int*>(tmp_sendbuf)[1], static_cast<int*>(tmp_recvbuf)[0], static_cast<int*>(tmp_recvbuf)[1]);
if(ep_rank != my_src)
{
MPI_Request request[2];
MPI_Status status[2];
MPI_Isend(tmp_recvbuf, count, datatype, my_src, my_src, comm, &request[0]);
MPI_Irecv(recvbuf, count, datatype, my_dst, ep_rank, comm, &request[1]);
MPI_Waitall(2, request, status);
}
else memcpy(recvbuf, tmp_recvbuf, datasize*count);
delete[] tmp_sendbuf;
delete[] tmp_recvbuf;
}
static off_t
scn_data_layout(Elf_Scn *scn, unsigned v, unsigned type, size_t *algn, unsigned *flag) {
Elf *elf = scn->s_elf;
Elf_Data *data;
int layout = (elf->e_elf_flags & ELF_F_LAYOUT) == 0;
size_t scn_align = 1;
size_t len = 0;
Scn_Data *sd;
size_t fsize;
if (!(sd = scn->s_data_1)) {
/* no data in section */
*algn = scn_align;
return (off_t)len;
}
/* load data from file, if any */
if (!(data = elf_getdata(scn, NULL))) {
return (off_t)-1;
}
elf_assert(data == &sd->sd_data);
for (; sd; sd = sd->sd_link) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
if (!valid_version(sd->sd_data.d_version)) {
return (off_t)-1;
}
fsize = sd->sd_data.d_size;
if (fsize && type != SHT_NOBITS && valid_type(sd->sd_data.d_type)) {
if (elf->e_class == ELFCLASS32) {
fsize = _elf32_xltsize(&sd->sd_data, v, ELFDATA2LSB, 1);
}
#if __LIBELF64
else if (elf->e_class == ELFCLASS64) {
fsize = _elf64_xltsize(&sd->sd_data, v, ELFDATA2LSB, 1);
}
#endif /* __LIBELF64 */
else {
elf_assert(valid_class(elf->e_class));
seterr(ERROR_UNIMPLEMENTED);
return (off_t)-1;
}
if (fsize == (size_t)-1) {
return (off_t)-1;
}
}
if (layout) {
align(len, sd->sd_data.d_align);
scn_align = max(scn_align, sd->sd_data.d_align);
rewrite(sd->sd_data.d_off, (off_t)len, sd->sd_data_flags);
len += fsize;
}
else {
len = max(len, sd->sd_data.d_off + fsize);
}
*flag |= sd->sd_data_flags;
}
*algn = scn_align;
return (off_t)len;
}
void dump_program(struct state *state)
{
int i, sect_size;
uint8_t *ptr;
state->hdr = next_sect(state, §_size);
printf("######## HEADER: (size %d)\n", sect_size);
printf("\tsize: %d\n", state->hdr->size);
printf("\tattributes: %d\n", state->hdr->num_attribs);
printf("\tuniforms: %d\n", state->hdr->num_uniforms);
printf("\tsamplers: %d\n", state->hdr->num_samplers);
printf("\tvaryings: %d\n", state->hdr->num_varyings);
if (full_dump)
dump_hex((void *)state->hdr, sect_size);
printf("\n");
/* there seems to be two 0xba5eba11's at the end of the header, possibly
* with some other stuff between them:
*/
next_sect(state, §_size);
for (i = 0; (i < state->hdr->num_attribs) && (state->sz > 0); i++) {
state->attribs[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->attribs[i]->type_info))
state->attribs[i] = next_sect(state, §_size);
clean_ascii(state->attribs[i]->name, sect_size - 28);
if (full_dump) {
printf("######## ATTRIBUTE: (size %d)\n", sect_size);
dump_attribute(state->attribs[i]);
dump_hex((char *)state->attribs[i], sect_size);
}
}
for (i = 0; (i < state->hdr->num_uniforms) && (state->sz > 0); i++) {
state->uniforms[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->uniforms[i]->type_info))
state->uniforms[i] = next_sect(state, §_size);
clean_ascii(state->uniforms[i]->name, sect_size - 41);
if (full_dump) {
printf("######## UNIFORM: (size %d)\n", sect_size);
dump_uniform(state->uniforms[i]);
dump_hex((char *)state->uniforms[i], sect_size);
}
}
for (i = 0; (i < state->hdr->num_samplers) && (state->sz > 0); i++) {
state->samplers[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->samplers[i]->type_info))
state->samplers[i] = next_sect(state, §_size);
clean_ascii(state->samplers[i]->name, sect_size - 33);
if (full_dump) {
printf("######## SAMPLER: (size %d)\n", sect_size);
dump_sampler(state->samplers[i]);
dump_hex((char *)state->samplers[i], sect_size);
}
}
for (i = 0; (i < state->hdr->num_varyings) && (state->sz > 0); i++) {
state->varyings[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->varyings[i]->type_info))
state->varyings[i] = next_sect(state, §_size);
clean_ascii(state->varyings[i]->name, sect_size - 16);
if (full_dump) {
printf("######## VARYING: (size %d)\n", sect_size);
dump_varying(state->varyings[i]);
dump_hex((char *)state->varyings[i], sect_size);
}
}
if (gpu_id >= 300) {
dump_shaders_a3xx(state);
} else {
dump_shaders_a2xx(state);
}
if (!full_dump)
return;
/* dump ascii version of shader program: */
ptr = next_sect(state, §_size);
printf("\n#######################################################\n");
printf("######## SHADER SRC: (size=%d)\n", sect_size);
dump_ascii(ptr, sect_size);
free(ptr);
/* dump remaining sections (there shouldn't be any): */
while (state->sz > 0) {
ptr = next_sect(state, §_size);
printf("######## section (size=%d)\n", sect_size);
printf("as hex:\n");
dump_hex(ptr, sect_size);
printf("as float:\n");
dump_float(ptr, sect_size);
printf("as ascii:\n");
dump_ascii(ptr, sect_size);
free(ptr);
}
}
value HTMLHeader::evaluate() const {
if(valid_type())
return(value("<!DOCTYPE html><html><body>"+x->evaluate().getStr_val()+"</body></html>", String));
else
return(value("ERROR:HTMLHeader", -1));
}
static off_t
_elf64_write(Elf *elf, char *outbuf, size_t len) {
Elf64_Ehdr *ehdr;
Elf64_Shdr *shdr;
Elf_Scn *scn;
Scn_Data *sd;
Elf_Data src;
Elf_Data dst;
unsigned encode;
elf_assert(len);
elf_assert(elf->e_ehdr);
ehdr = (Elf64_Ehdr*)elf->e_ehdr;
encode = ehdr->e_ident[EI_DATA];
src.d_buf = ehdr;
src.d_type = ELF_T_EHDR;
src.d_size = _msize(ELFCLASS64, _elf_version, ELF_T_EHDR);
src.d_version = _elf_version;
dst.d_buf = outbuf;
dst.d_size = ehdr->e_ehsize;
dst.d_version = ehdr->e_version;
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
if (ehdr->e_phnum) {
src.d_buf = elf->e_phdr;
src.d_type = ELF_T_PHDR;
src.d_size = ehdr->e_phnum * _msize(ELFCLASS64, _elf_version, ELF_T_PHDR);
src.d_version = _elf_version;
dst.d_buf = outbuf + ehdr->e_phoff;
dst.d_size = ehdr->e_phnum * ehdr->e_phentsize;
dst.d_version = ehdr->e_version;
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
}
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf == elf);
src.d_buf = &scn->s_uhdr;
src.d_type = ELF_T_SHDR;
src.d_size = _msize(ELFCLASS64, EV_CURRENT, ELF_T_SHDR);
src.d_version = EV_CURRENT;
dst.d_buf = outbuf + ehdr->e_shoff + scn->s_index * ehdr->e_shentsize;
dst.d_size = ehdr->e_shentsize;
dst.d_version = ehdr->e_version;
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
if (scn->s_index == SHN_UNDEF) {
continue;
}
shdr = &scn->s_shdr64;
if (shdr->sh_type == SHT_NULL || shdr->sh_type == SHT_NOBITS) {
continue;
}
/* XXX: this is probably no longer necessary */
if (scn->s_data_1 && !elf_getdata(scn, NULL)) {
return -1;
}
for (sd = scn->s_data_1; sd; sd = sd->sd_link) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
src = sd->sd_data;
if (!src.d_size) {
continue;
}
if (!src.d_buf) {
seterr(ERROR_NULLBUF);
return -1;
}
dst.d_buf = outbuf + shdr->sh_offset + src.d_off;
dst.d_size = src.d_size;
dst.d_version = ehdr->e_version;
if (valid_type(src.d_type)) {
size_t tmp;
tmp = _elf64_xltsize(&src, dst.d_version, ELFDATA2LSB, 1);
if (tmp == (size_t)-1) {
return -1;
}
dst.d_size = tmp;
}
else {
src.d_type = ELF_T_BYTE;
}
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
}
}
/* cleanup */
if (elf->e_readable && _elf_update_pointers(elf, outbuf, len)) {
return -1;
}
/* NOTE: ehdr is no longer valid! */
ehdr = (Elf64_Ehdr*)elf->e_ehdr; elf_assert(ehdr);
elf->e_encoding = ehdr->e_ident[EI_DATA];
elf->e_version = ehdr->e_ident[EI_VERSION];
elf->e_elf_flags &= ~ELF_F_DIRTY;
elf->e_ehdr_flags &= ~ELF_F_DIRTY;
elf->e_phdr_flags &= ~ELF_F_DIRTY;
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
scn->s_scn_flags &= ~ELF_F_DIRTY;
scn->s_shdr_flags &= ~ELF_F_DIRTY;
for (sd = scn->s_data_1; sd; sd = sd->sd_link) {
sd->sd_data_flags &= ~ELF_F_DIRTY;
}
if (elf->e_readable) {
shdr = &scn->s_shdr64;
scn->s_type = shdr->sh_type;
scn->s_size = shdr->sh_size;
scn->s_offset = shdr->sh_offset;
}
}
elf->e_size = len;
return len;
}
int HTMLHeader::infer_type() const {
if(valid_type())
return(String);
else
return(-1);
}
/*
* Set an individual arp entry
*/
static int
set(int argc, char **argv)
{
struct sockaddr_in *addr;
struct sockaddr_in *dst; /* what are we looking for */
struct sockaddr_dl *sdl;
struct rt_msghdr *rtm;
struct ether_addr *ea;
char *host = argv[0], *eaddr = argv[1];
struct sockaddr_dl sdl_m;
argc -= 2;
argv += 2;
bzero(&sdl_m, sizeof(sdl_m));
sdl_m.sdl_len = sizeof(sdl_m);
sdl_m.sdl_family = AF_LINK;
dst = getaddr(host);
if (dst == NULL)
return (1);
doing_proxy = flags = expire_time = 0;
while (argc-- > 0) {
if (strncmp(argv[0], "temp", 4) == 0) {
struct timespec tp;
int max_age;
size_t len = sizeof(max_age);
clock_gettime(CLOCK_MONOTONIC, &tp);
if (sysctlbyname("net.link.ether.inet.max_age",
&max_age, &len, NULL, 0) != 0)
err(1, "sysctlbyname");
expire_time = tp.tv_sec + max_age;
} else if (strncmp(argv[0], "pub", 3) == 0) {
flags |= RTF_ANNOUNCE;
doing_proxy = 1;
if (argc && strncmp(argv[1], "only", 3) == 0) {
/*
* Compatibility: in pre FreeBSD 8 times
* the "only" keyword used to mean that
* an ARP entry should be announced, but
* not installed into routing table.
*/
argc--; argv++;
}
} else if (strncmp(argv[0], "blackhole", 9) == 0) {
if (flags & RTF_REJECT) {
printf("Choose one of blackhole or reject, not both.\n");
}
flags |= RTF_BLACKHOLE;
} else if (strncmp(argv[0], "reject", 6) == 0) {
if (flags & RTF_BLACKHOLE) {
printf("Choose one of blackhole or reject, not both.\n");
}
flags |= RTF_REJECT;
} else if (strncmp(argv[0], "trail", 5) == 0) {
/* XXX deprecated and undocumented feature */
printf("%s: Sending trailers is no longer supported\n",
host);
}
argv++;
}
ea = (struct ether_addr *)LLADDR(&sdl_m);
if (doing_proxy && !strcmp(eaddr, "auto")) {
if (!get_ether_addr(dst->sin_addr.s_addr, ea)) {
printf("no interface found for %s\n",
inet_ntoa(dst->sin_addr));
return (1);
}
sdl_m.sdl_alen = ETHER_ADDR_LEN;
} else {
struct ether_addr *ea1 = ether_aton(eaddr);
if (ea1 == NULL) {
warnx("invalid Ethernet address '%s'", eaddr);
return (1);
} else {
*ea = *ea1;
sdl_m.sdl_alen = ETHER_ADDR_LEN;
}
}
/*
* In the case a proxy-arp entry is being added for
* a remote end point, the RTF_ANNOUNCE flag in the
* RTM_GET command is an indication to the kernel
* routing code that the interface associated with
* the prefix route covering the local end of the
* PPP link should be returned, on which ARP applies.
*/
rtm = rtmsg(RTM_GET, dst, &sdl_m);
if (rtm == NULL) {
warn("%s", host);
return (1);
}
addr = (struct sockaddr_in *)(rtm + 1);
sdl = (struct sockaddr_dl *)(SA_SIZE(addr) + (char *)addr);
if ((sdl->sdl_family != AF_LINK) ||
(rtm->rtm_flags & RTF_GATEWAY) ||
!valid_type(sdl->sdl_type)) {
printf("cannot intuit interface index and type for %s\n", host);
return (1);
}
sdl_m.sdl_type = sdl->sdl_type;
sdl_m.sdl_index = sdl->sdl_index;
return (rtmsg(RTM_ADD, dst, &sdl_m) == NULL);
}
double total_time(timer_type type=TOTAL_TIME) const
{
if (!valid_type(type))
throw std::runtime_error("stopwatch: invalid timer type");
return totals[type] + recent_time(type);
}
static int
handle_string(void *ctx, const unsigned char *stringVal, unsigned int stringLen)
{
struct parse_context *pctx = (struct parse_context *)ctx;
var_type type;
Var v;
const char *val = (const char *)stringVal;
size_t len = (size_t)stringLen;
if (MODE_EMBEDDED_TYPES == pctx->mode
&& TYPE_NONE != (type = valid_type(&val, &len))) {
switch (type) {
case TYPE_OBJ:
{
char *p;
if (*val == '#')
val++;
v.type = TYPE_OBJ;
v.v.num = strtol(val, &p, 10);
break;
}
case TYPE_INT:
{
char *p;
v = new_int(strtol(val, &p, 10));
break;
}
case TYPE_FLOAT:
{
char *p;
v = new_float(strtod(val, &p));
break;
}
case TYPE_ERR:
{
char temp[len + 1];
strncpy(temp, val, len);
temp[len] = '\0';
v.type = TYPE_ERR;
int err = parse_error(temp);
v.v.err = err > -1 ? err : E_NONE;
break;
}
case TYPE_STR:
{
char temp[len + 1];
strncpy(temp, val, len);
temp[len] = '\0';
v.type = TYPE_STR;
v.v.str = str_dup(temp);
break;
}
default:
panic("Unsupported type in handle_string()");
}
} else {
char temp[len + 1];
strncpy(temp, val, len);
temp[len] = '\0';
v.type = TYPE_STR;
v.v.str = str_dup(temp);
}
PUSH(pctx->top, v);
return 1;
}
void dump_program(struct state *state)
{
int i, sect_size;
uint8_t *ptr;
state->hdr = next_sect(state, §_size);
printf("######## HEADER: (size %d)\n", sect_size);
printf("\tsize: %d\n", state->hdr->size);
printf("\trevision: %d\n", state->hdr->revision);
printf("\tattributes: %d\n", state->hdr->num_attribs);
printf("\tuniforms: %d\n", state->hdr->num_uniforms);
printf("\tsamplers: %d\n", state->hdr->num_samplers);
printf("\tvaryings: %d\n", state->hdr->num_varyings);
printf("\tuniform blocks: %d\n", state->hdr->num_uniformblocks);
if (full_dump)
dump_hex((void *)state->hdr, sect_size);
printf("\n");
/* there seems to be two 0xba5eba11's at the end of the header, possibly
* with some other stuff between them:
*/
ptr = next_sect(state, §_size);
if (full_dump) {
dump_hex_ascii(ptr, sect_size);
}
for (i = 0; (i < state->hdr->num_attribs) && (state->sz > 0); i++) {
state->attribs[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->attribs[i]->type_info)) {
dump_hex_ascii(state->attribs[i], sect_size);
state->attribs[i] = next_sect(state, §_size);
}
clean_ascii(state->attribs[i]->name, sect_size - 28);
if (full_dump) {
printf("######## ATTRIBUTE: (size %d)\n", sect_size);
dump_attribute(state->attribs[i]);
dump_hex((char *)state->attribs[i], sect_size);
}
}
for (i = 0; (i < state->hdr->num_uniforms) && (state->sz > 0); i++) {
state->uniforms[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->uniforms[i]->type_info)) {
dump_hex_ascii(state->uniforms[i], sect_size);
state->uniforms[i] = next_sect(state, §_size);
}
if (is_uniform_v2(state->uniforms[i])) {
clean_ascii(state->uniforms[i]->v2.name, sect_size - 53);
} else {
clean_ascii(state->uniforms[i]->v1.name, sect_size - 41);
}
if (full_dump) {
printf("######## UNIFORM: (size %d)\n", sect_size);
dump_uniform(state->uniforms[i]);
dump_hex((char *)state->uniforms[i], sect_size);
}
}
for (i = 0; (i < state->hdr->num_samplers) && (state->sz > 0); i++) {
state->samplers[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->samplers[i]->type_info)) {
dump_hex_ascii(state->samplers[i], sect_size);
state->samplers[i] = next_sect(state, §_size);
}
clean_ascii(state->samplers[i]->name, sect_size - 33);
if (full_dump) {
printf("######## SAMPLER: (size %d)\n", sect_size);
dump_sampler(state->samplers[i]);
dump_hex((char *)state->samplers[i], sect_size);
}
}
// These sections show up after all of the other sampler sections
// Loops through them all since we don't deal with them
if (state->hdr->revision >= 7) {
for (i = 0; (i < state->hdr->num_samplers) && (state->sz > 0); i++) {
ptr = next_sect(state, §_size);
dump_hex_ascii(ptr, sect_size);
}
}
for (i = 0; (i < state->hdr->num_varyings) && (state->sz > 0); i++) {
state->varyings[i] = next_sect(state, §_size);
/* hmm, for a3xx (or maybe just newer driver version), we have some
* extra sections that don't seem useful, so skip these:
*/
while (!valid_type(state->varyings[i]->type_info)) {
dump_hex_ascii(state->varyings[i], sect_size);
state->varyings[i] = next_sect(state, §_size);
}
clean_ascii(state->varyings[i]->name, sect_size - 16);
if (full_dump) {
printf("######## VARYING: (size %d)\n", sect_size);
dump_varying(state->varyings[i]);
dump_hex((char *)state->varyings[i], sect_size);
}
}
/* not sure exactly which revision started this, but seems at least
* rev7 and rev8 implicitly include a new section for gl_FragColor:
*/
if (state->hdr->revision >= 7) {
/* I guess only one? */
state->outputs[0] = next_sect(state, §_size);
clean_ascii(state->outputs[0]->name, sect_size - 32);
if (full_dump) {
printf("######## OUTPUT: (size %d)\n", sect_size);
dump_output(state->outputs[0]);
dump_hex((char *)state->outputs[0], sect_size);
}
}
for (i = 0; (i < state->hdr->num_uniformblocks) && (state->sz > 0); i++) {
state->uniformblocks[i].header = next_sect(state, §_size);
clean_ascii(state->uniformblocks[i].header->name, sect_size - 40);
if (full_dump) {
printf("######## UNIFORM BLOCK: (size %d)\n", sect_size);
dump_uniformblock(state->uniformblocks[i].header);
dump_hex((char *)state->uniformblocks[i].header, sect_size);
}
/*
* OpenGL ES 3.0 spec mandates a minimum amount of 16K members supported
* a330 supports a minimum of 65K
*/
state->uniformblocks[i].members = malloc(state->uniformblocks[i].header->num_members * sizeof(void*));
int member = 0;
for (member = 0; (member < state->uniformblocks[i].header->num_members) && (state->sz > 0); member++) {
state->uniformblocks[i].members[member] = next_sect(state, §_size);
clean_ascii(state->uniformblocks[i].members[member]->name, sect_size - 56);
if (full_dump) {
printf("######## UNIFORM BLOCK MEMBER: (size %d)\n", sect_size);
dump_uniformblockmember(state->uniformblocks[i].members[member]);
dump_hex((char *)state->uniformblocks[i].members[member], sect_size);
}
}
/*
* Qualcomm saves the UBO members twice for each UBO
* Don't ask me why
*/
for (member = 0; (member < state->uniformblocks[i].header->num_members) && (state->sz > 0); member++) {
state->uniformblocks[i].members[member] = next_sect(state, §_size);
clean_ascii(state->uniformblocks[i].members[member]->name, sect_size - 56);
if (full_dump) {
printf("######## UNIFORM BLOCK MEMBER2: (size %d)\n", sect_size);
dump_uniformblockmember(state->uniformblocks[i].members[member]);
dump_hex((char *)state->uniformblocks[i].members[member], sect_size);
}
}
}
if (gpu_id >= 300) {
dump_shaders_a3xx(state);
} else {
dump_shaders_a2xx(state);
}
if (!full_dump)
return;
/* dump ascii version of shader program: */
ptr = next_sect(state, §_size);
printf("\n#######################################################\n");
printf("######## SHADER SRC: (size=%d)\n", sect_size);
dump_ascii(ptr, sect_size);
free(ptr);
/* dump remaining sections (there shouldn't be any): */
while (state->sz > 0) {
ptr = next_sect(state, §_size);
printf("######## section (size=%d)\n", sect_size);
printf("as hex:\n");
dump_hex(ptr, sect_size);
printf("as float:\n");
dump_float(ptr, sect_size);
printf("as ascii:\n");
dump_ascii(ptr, sect_size);
free(ptr);
}
/* cleanup the uniform buffer members we allocated */
if (state->hdr->num_uniformblocks > 0)
free (state->uniformblocks[i].members);
}
