void operator()(Field_decl const* d) { mangle(os, d); }
Symbol *VarDeclaration::toSymbol() { //printf("VarDeclaration::toSymbol(%s)\n", toChars()); //if (needThis()) *(char*)0=0; assert(!needThis()); if (!csym) { Symbol *s; TYPE *t; const char *id; mangle_t m = 0; if (isDataseg()) id = mangle(); else id = ident->toChars(); s = symbol_calloc(id); if (storage_class & (STCout | STCref)) { if (global.params.symdebug && storage_class & STCparameter) { t = type_alloc(TYnptr); // should be TYref, but problems in back end t->Tnext = type->toCtype(); t->Tnext->Tcount++; } else t = type_fake(TYnptr); } else if (storage_class & STClazy) t = type_fake(TYdelegate); // Tdelegate as C type else if (isParameter()) t = type->toCParamtype(); else t = type->toCtype(); t->Tcount++; if (isDataseg()) { if (storage_class & STCtls) { /* Thread local storage */ type_setty(&t, t->Tty | mTYthread); } s->Sclass = SCextern; s->Sfl = FLextern; slist_add(s); } else { s->Sclass = SCauto; s->Sfl = FLauto; if (nestedref) { /* Symbol is accessed by a nested function. Make sure * it is not put in a register, and that the optimizer * assumes it is modified across function calls and pointer * dereferences. */ //printf("\tnested ref, not register\n"); type_setcv(&t, t->Tty | mTYvolatile); } } if (storage_class & STCconst) { // Insert const modifiers tym_t tym = 0; if (storage_class & STCconst) tym |= mTYconst; type_setcv(&t, tym); } switch (linkage) { case LINKwindows: m = mTYman_std; break; case LINKpascal: m = mTYman_pas; break; case LINKc: m = mTYman_c; break; case LINKd: m = mTYman_d; break; case LINKcpp: m = mTYman_cpp; break; default: printf("linkage = %d\n", linkage); assert(0); } type_setmangle(&t, m); s->Stype = t; csym = s; } return csym; }
void test_cpp_fixture_function (gconstpointer data) { const FixtureTestData *test_data = data; CutStartupFunction expected_startup_function = NULL; CutStartupFunction actual_startup_function = NULL; CutShutdownFunction expected_shutdown_function = NULL; CutShutdownFunction actual_shutdown_function = NULL; CutSetupFunction expected_setup_function = NULL; CutSetupFunction actual_setup_function = NULL; CutTeardownFunction expected_teardown_function = NULL; CutTeardownFunction actual_teardown_function = NULL; gchar *so_filename; loader = loader_new("cpp-fixture", test_data->file_name); test_case = cut_loader_load_test_case(loader); cut_assert(test_case); g_object_get(G_OBJECT(loader), "so-filename", &so_filename, NULL); module = g_module_open(so_filename, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL); g_free(so_filename); cut_assert_not_null(module); if (test_data->startup_function_name) cut_assert_true(g_module_symbol(module, mangle("fixture", test_data->startup_function_name, NULL), (gpointer)&expected_startup_function)); if (test_data->setup_function_name) cut_assert_true(g_module_symbol(module, mangle("fixture", test_data->setup_function_name, NULL), (gpointer)&expected_setup_function)); if (test_data->teardown_function_name) cut_assert_true(g_module_symbol(module, mangle("fixture", test_data->teardown_function_name, NULL), (gpointer)&expected_teardown_function)); if (test_data->shutdown_function_name) cut_assert_true(g_module_symbol(module, mangle("fixture", test_data->shutdown_function_name, NULL), (gpointer)&expected_shutdown_function)); g_object_get(G_OBJECT(test_case), "startup-function", &actual_startup_function, "setup-function", &actual_setup_function, "teardown-function", &actual_teardown_function, "shutdown-function", &actual_shutdown_function, NULL); cut_assert_equal_pointer(expected_startup_function, actual_startup_function); cut_assert_equal_pointer(expected_setup_function, actual_setup_function); cut_assert_equal_pointer(expected_teardown_function, actual_teardown_function); cut_assert_equal_pointer(expected_shutdown_function, actual_shutdown_function); }
/* a < may be just a regular character, the start of an embedded html * tag, or the start of an <automatic link>. If it's an automatic * link, we also need to know if it's an email address because if it * is we need to mangle it in our futile attempt to cut down on the * spaminess of the rendered page. */ static int maybe_tag_or_link(MMIOT *f) { char *text; int c, size, i; int maybetag=1, maybeaddress=0; int mailto; if ( f->flags & INSIDE_TAG ) return 0; for ( size=0; ((c = peek(f,size+1)) != '>') && !isspace(c); size++ ) { if ( ! (c == '/' || isalnum(c) || c == '~') ) maybetag=0; if ( c == '@' ) maybeaddress=1; else if ( c == EOF ) return 0; } if ( size == 0 ) return 0; if ( maybetag || (size >= 3 && strncmp(cursor(f), "!--", 3) == 0) ) { Qstring(forbidden_tag(f) ? "<" : "<", f); while ( ((c = peek(f, 1)) != EOF) && (c != '>') ) cputc(pull(f), f); return 1; } if ( f->flags & DENY_A ) return 0; text = cursor(f); shift(f, size+1); for ( i=0; i < SZAUTOPREFIX; i++ ) if ( strncasecmp(text, autoprefix[i], strlen(autoprefix[i])) == 0 ) { Qstring("<a href=\"", f); puturl(text,size,f); Qstring("\">", f); puturl(text,size,f); Qstring("</a>", f); return 1; } if ( maybeaddress ) { Qstring("<a href=\"", f); if ( (size > 7) && strncasecmp(text, "mailto:", 7) == 0 ) mailto = 7; else { mailto = 0; /* supply a mailto: protocol if one wasn't attached */ mangle("mailto:", 7, f); } mangle(text, size, f); Qstring("\">", f); mangle(text+mailto, size-mailto, f); Qstring("</a>", f); return 1; } shift(f, -(size+1)); return 0; } /* maybe_tag_or_link */
static int mountfs(const char *vfstype, const char *spec, const char *name, int flags, const char *options, const char *mntopts) { /* List of directories containing mount_xxx subcommands. */ static const char *edirs[] = { _PATH_SBIN, _PATH_USRSBIN, NULL }; const char *argv[100], **edir; struct statfs sf; pid_t pid; int argc, i, status; char *optbuf, execname[MAXPATHLEN + 1], mntpath[MAXPATHLEN]; #if __GNUC__ (void)&optbuf; (void)&name; #endif /* resolve the mountpoint with realpath(3) */ checkpath(name, mntpath); name = mntpath; if (mntopts == NULL) mntopts = ""; if (options == NULL) { if (*mntopts == '\0') { options = "rw"; } else { options = mntopts; mntopts = ""; } } optbuf = catopt(xstrdup(mntopts), options); if (strcmp(name, "/") == 0) flags |= MNT_UPDATE; if (flags & MNT_FORCE) optbuf = catopt(optbuf, "force"); if (flags & MNT_RDONLY) optbuf = catopt(optbuf, "ro"); /* * XXX * The mount_mfs (newfs) command uses -o to select the * optimization mode. We don't pass the default "-o rw" * for that reason. */ if (flags & MNT_UPDATE) optbuf = catopt(optbuf, "update"); argc = 0; argv[argc++] = vfstype; mangle(optbuf, &argc, argv); argv[argc++] = spec; argv[argc++] = name; argv[argc] = NULL; if (debug) { printf("exec: mount_%s", vfstype); for (i = 1; i < argc; i++) printf(" %s", argv[i]); printf("\n"); return (0); } switch (pid = fork()) { case -1: /* Error. */ warn("fork"); free(optbuf); return (1); case 0: /* Child. */ /* Go find an executable. */ for (edir = edirs; *edir; edir++) { snprintf(execname, sizeof(execname), "%s/mount_%s", *edir, vfstype); execv(execname, __DECONST(char * const *, argv)); } if (errno == ENOENT) { int len = 0; char *cp; for (edir = edirs; *edir; edir++) len += strlen(*edir) + 2; /* ", " */ if ((cp = malloc(len)) == NULL) errx(1, "malloc failed"); cp[0] = '\0'; for (edir = edirs; *edir; edir++) { strcat(cp, *edir); if (edir[1] != NULL) strcat(cp, ", "); } warn("exec mount_%s not found in %s", vfstype, cp); } exit(1); /* NOTREACHED */ default: /* Parent. */ free(optbuf); if (waitpid(pid, &status, 0) < 0) { warn("waitpid"); return (1); } if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return (WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { warnx("%s: %s", name, sys_siglist[WTERMSIG(status)]); return (1); } if (verbose) { if (statfs(name, &sf) < 0) { warn("statfs %s", name); return (1); } if (fstab_style) putfsent(&sf); else prmount(&sf); } break; } return (0); }
llvm::GlobalVariable * IrStruct::getInterfaceVtbl(BaseClass * b, bool new_instance, size_t interfaces_index) { ClassGlobalMap::iterator it = interfaceVtblMap.find(b->base); if (it != interfaceVtblMap.end()) return it->second; IF_LOG Logger::println("Building vtbl for implementation of interface %s in class %s", b->base->toPrettyChars(), aggrdecl->toPrettyChars()); LOG_SCOPE; ClassDeclaration* cd = aggrdecl->isClassDeclaration(); assert(cd && "not a class aggregate"); FuncDeclarations vtbl_array; b->fillVtbl(cd, &vtbl_array, new_instance); std::vector<llvm::Constant*> constants; constants.reserve(vtbl_array.dim); // start with the interface info VarDeclarationIter interfaces_idx(ClassDeclaration::classinfo->fields, 3); // index into the interfaces array llvm::Constant* idxs[2] = { DtoConstSize_t(0), DtoConstSize_t(interfaces_index) }; llvm::Constant* c = llvm::ConstantExpr::getGetElementPtr( getInterfaceArraySymbol(), idxs, true); constants.push_back(c); // add virtual function pointers size_t n = vtbl_array.dim; for (size_t i = 1; i < n; i++) { Dsymbol* dsym = static_cast<Dsymbol*>(vtbl_array.data[i]); if (dsym == NULL) { // FIXME // why is this null? // happens for mini/s.d constants.push_back(getNullValue(getVoidPtrType())); continue; } FuncDeclaration* fd = dsym->isFuncDeclaration(); assert(fd && "vtbl entry not a function"); assert((!fd->isAbstract() || fd->fbody) && "null symbol in interface implementation vtable"); fd->codegen(Type::sir); assert(fd->ir.irFunc && "invalid vtbl function"); constants.push_back(fd->ir.irFunc->func); } // build the vtbl constant llvm::Constant* vtbl_constant = LLConstantStruct::getAnon(gIR->context(), constants, false); // create the global variable to hold it llvm::GlobalValue::LinkageTypes _linkage = DtoExternalLinkage(aggrdecl); std::string mangle("_D"); mangle.append(cd->mangle()); mangle.append("11__interface"); mangle.append(b->base->mangle()); mangle.append("6__vtblZ"); llvm::GlobalVariable* GV = new llvm::GlobalVariable( *gIR->module, vtbl_constant->getType(), true, _linkage, vtbl_constant, mangle ); // insert into the vtbl map interfaceVtblMap.insert(std::make_pair(b->base, GV)); return GV; }
void ldobj1(Biobuf *f, char *pkg, int64 len, char *pn) { int32 ipc; Prog *p; int v, o, r, skip; Sym *h[NSYM], *s; uint32 sig; int ntext; int32 eof; char *name, *x; char src[1024]; Prog *lastp; lastp = nil; ntext = 0; eof = Boffset(f) + len; src[0] = 0; newloop: memset(h, 0, sizeof(h)); version++; histfrogp = 0; ipc = pc; skip = 0; loop: if(f->state == Bracteof || Boffset(f) >= eof) goto eof; o = Bgetc(f); if(o == Beof) goto eof; o |= Bgetc(f) << 8; if(o <= AXXX || o >= ALAST) { if(o < 0) goto eof; diag("%s:#%lld: opcode out of range: %#ux", pn, Boffset(f), o); print(" probably not a .%c file\n", thechar); errorexit(); } if(o == ANAME || o == ASIGNAME) { sig = 0; if(o == ASIGNAME) sig = Bget4(f); v = Bgetc(f); /* type */ o = Bgetc(f); /* sym */ r = 0; if(v == D_STATIC) r = version; name = Brdline(f, '\0'); if(name == nil) { if(Blinelen(f) > 0) { fprint(2, "%s: name too long\n", pn); errorexit(); } goto eof; } x = expandpkg(name, pkg); s = lookup(x, r); if(x != name) free(x); if(debug['S'] && r == 0) sig = 1729; if(sig != 0){ if(s->sig != 0 && s->sig != sig) diag("incompatible type signatures " "%ux(%s) and %ux(%s) for %s", s->sig, s->file, sig, pn, s->name); s->sig = sig; s->file = pn; } if(debug['W']) print(" ANAME %s\n", s->name); if(o < 0 || o >= nelem(h)) mangle(pn); h[o] = s; if((v == D_EXTERN || v == D_STATIC) && s->type == 0) s->type = SXREF; if(v == D_FILE) { if(s->type != SFILE) { histgen++; s->type = SFILE; s->value = histgen; } if(histfrogp < MAXHIST) { histfrog[histfrogp] = s; histfrogp++; } else collapsefrog(s); dwarfaddfrag(s->value, s->name); } goto loop; } p = mal(sizeof(*p)); p->as = o; p->line = Bget4(f); p->back = 2; p->ft = 0; p->tt = 0; zaddr(pn, f, &p->from, h); fromgotype = adrgotype; zaddr(pn, f, &p->to, h); if(debug['W']) print("%P\n", p); switch(p->as) { case AHISTORY: if(p->to.offset == -1) { addlib(src, pn); histfrogp = 0; goto loop; } if(src[0] == '\0') copyhistfrog(src, sizeof src); addhist(p->line, D_FILE); /* 'z' */ if(p->to.offset) addhist(p->to.offset, D_FILE1); /* 'Z' */ histfrogp = 0; goto loop; case AEND: histtoauto(); if(cursym != nil && cursym->text) cursym->autom = curauto; curauto = 0; cursym = nil; if(Boffset(f) == eof) return; goto newloop; case AGLOBL: s = p->from.sym; if(s->type == 0 || s->type == SXREF) { s->type = SBSS; s->size = 0; } if(s->type != SBSS && s->type != SNOPTRBSS && !s->dupok) { diag("%s: redefinition: %s in %s", pn, s->name, TNAME); s->type = SBSS; s->size = 0; } if(p->to.offset > s->size) s->size = p->to.offset; if(p->from.scale & DUPOK) s->dupok = 1; if(p->from.scale & RODATA) s->type = SRODATA; else if(p->from.scale & NOPTR) s->type = SNOPTRBSS; goto loop; case ADATA: // Assume that AGLOBL comes after ADATA. // If we've seen an AGLOBL that said this sym was DUPOK, // ignore any more ADATA we see, which must be // redefinitions. s = p->from.sym; if(s->dupok) { // if(debug['v']) // Bprint(&bso, "skipping %s in %s: dupok\n", s->name, pn); goto loop; } if(s->file == nil) s->file = pn; else if(s->file != pn) { diag("multiple initialization for %s: in both %s and %s", s->name, s->file, pn); errorexit(); } savedata(s, p, pn); unmal(p, sizeof *p); goto loop; case AGOK: diag("%s: GOK opcode in %s", pn, TNAME); pc++; goto loop; case ATEXT: s = p->from.sym; if(s->text != nil) { if(p->from.scale & DUPOK) { skip = 1; goto casdef; } diag("%s: %s: redefinition", pn, s->name); return; } if(ntext++ == 0 && s->type != 0 && s->type != SXREF) { /* redefinition, so file has probably been seen before */ if(debug['v']) diag("skipping: %s: redefinition: %s", pn, s->name); return; } if(cursym != nil && cursym->text) { histtoauto(); cursym->autom = curauto; curauto = 0; } skip = 0; if(etextp) etextp->next = s; else textp = s; etextp = s; s->text = p; cursym = s; if(s->type != 0 && s->type != SXREF) { if(p->from.scale & DUPOK) { skip = 1; goto casdef; } diag("%s: redefinition: %s\n%P", pn, s->name, p); } s->type = STEXT; s->value = pc; lastp = p; p->pc = pc++; goto loop; case AFMOVF: case AFADDF: case AFSUBF: case AFSUBRF: case AFMULF: case AFDIVF: case AFDIVRF: case AFCOMF: case AFCOMFP: if(skip) goto casdef; if(p->from.type == D_FCONST) { /* size sb 9 max */ sprint(literal, "$%ux", ieeedtof(&p->from.ieee)); s = lookup(literal, 0); if(s->type == 0) { s->type = SDATA; adduint32(s, ieeedtof(&p->from.ieee)); s->reachable = 0; } p->from.type = D_EXTERN; p->from.sym = s; p->from.offset = 0; } goto casdef; case AFMOVD: case AFADDD: case AFSUBD: case AFSUBRD: case AFMULD: case AFDIVD: case AFDIVRD: case AFCOMD: case AFCOMDP: if(skip) goto casdef; if(p->from.type == D_FCONST) { /* size sb 18 max */ sprint(literal, "$%ux.%ux", p->from.ieee.l, p->from.ieee.h); s = lookup(literal, 0); if(s->type == 0) { s->type = SDATA; adduint32(s, p->from.ieee.l); adduint32(s, p->from.ieee.h); s->reachable = 0; } p->from.type = D_EXTERN; p->from.sym = s; p->from.offset = 0; } goto casdef; casdef: default: if(skip) nopout(p); p->pc = pc; pc++; if(p->to.type == D_BRANCH) p->to.offset += ipc; if(lastp == nil) { if(p->as != ANOP) diag("unexpected instruction: %P", p); goto loop; } lastp->link = p; lastp = p; goto loop; } eof: diag("truncated object file: %s", pn); }
llvm::orc::JITSymbol findSymbol(const std::string& name) { return mCompileLayer.findSymbol(mangle(name), true); }
int mountfs(const char *vfstype, const char *spec, const char *name, int flags, const char *options, const char *mntopts) { struct statfs sf; int i, ret; char *optbuf, execname[PATH_MAX], mntpath[PATH_MAX]; static struct cpa mnt_argv; /* resolve the mountpoint with realpath(3) */ if (checkpath(name, mntpath) != 0) { warn("%s", mntpath); return (1); } name = mntpath; if (mntopts == NULL) mntopts = ""; optbuf = catopt(strdup(mntopts), options); if (strcmp(name, "/") == 0) flags |= MNT_UPDATE; if (flags & MNT_FORCE) optbuf = catopt(optbuf, "force"); if (flags & MNT_RDONLY) optbuf = catopt(optbuf, "ro"); /* * XXX * The mount_mfs (newfs) command uses -o to select the * optimization mode. We don't pass the default "-o rw" * for that reason. */ if (flags & MNT_UPDATE) optbuf = catopt(optbuf, "update"); /* Compatibility glue. */ if (strcmp(vfstype, "msdos") == 0) { warnx( "Using \"-t msdosfs\", since \"-t msdos\" is deprecated."); vfstype = "msdosfs"; } /* Construct the name of the appropriate mount command */ (void)snprintf(execname, sizeof(execname), "mount_%s", vfstype); mnt_argv.c = -1; append_arg(&mnt_argv, execname); mangle(optbuf, &mnt_argv); if (mountprog != NULL) strcpy(execname, mountprog); append_arg(&mnt_argv, strdup(spec)); append_arg(&mnt_argv, strdup(name)); append_arg(&mnt_argv, NULL); if (debug) { if (use_mountprog(vfstype)) printf("exec: %s", execname); else printf("mount -t %s", vfstype); for (i = 1; i < mnt_argv.c; i++) (void)printf(" %s", mnt_argv.a[i]); (void)printf("\n"); free(optbuf); free(mountprog); mountprog = NULL; return (0); } if (use_mountprog(vfstype)) { ret = exec_mountprog(name, execname, mnt_argv.a); } else { ret = mount_fs(vfstype, mnt_argv.c, mnt_argv.a); } free(optbuf); free(mountprog); mountprog = NULL; if (verbose) { if (statfs(name, &sf) < 0) { warn("statfs %s", name); return (1); } if (fstab_style) putfsent(&sf); else prmount(&sf); } return (ret); }
// 'R' t void mangle(std::ostream& os, Reference_type const* t) { os << 'R'; mangle(os, t->type()); }
void VarDeclaration::codegen(Ir* p) { Logger::print("VarDeclaration::codegen(): %s | %s\n", toChars(), type->toChars()); LOG_SCOPE; if (type->ty == Terror) { error("had semantic errors when compiling"); return; } // just forward aliases if (aliassym) { Logger::println("alias sym"); toAlias()->codegen(p); return; } // output the parent aggregate first if (AggregateDeclaration* ad = isMember()) ad->codegen(p); // global variable if (isDataseg() || (storage_class & (STCconst | STCimmutable) && init)) { Logger::println("data segment"); #if 0 // TODO: assert(!(storage_class & STCmanifest) && "manifest constant being codegen'd!"); #endif // don't duplicate work if (this->ir.resolved) return; this->ir.resolved = true; this->ir.declared = true; this->ir.irGlobal = new IrGlobal(this); Logger::println("parent: %s (%s)", parent->toChars(), parent->kind()); const bool isLLConst = isConst() && init; const llvm::GlobalValue::LinkageTypes llLinkage = DtoLinkage(this); assert(!ir.initialized); ir.initialized = gIR->dmodule; std::string llName(mangle()); // Since the type of a global must exactly match the type of its // initializer, we cannot know the type until after we have emitted the // latter (e.g. in case of unions, …). However, it is legal for the // initializer to refer to the address of the variable. Thus, we first // create a global with the generic type (note the assignment to // this->ir.irGlobal->value!), and in case we also do an initializer // with a different type later, swap it out and replace any existing // uses with bitcasts to the previous type. llvm::GlobalVariable* gvar = getOrCreateGlobal(loc, *gIR->module, i1ToI8(DtoType(type)), isLLConst, llLinkage, 0, llName, isThreadlocal()); this->ir.irGlobal->value = gvar; // Check if we are defining or just declaring the global in this module. if (!(storage_class & STCextern) && mustDefineSymbol(this)) { // Build the initializer. Might use this->ir.irGlobal->value! LLConstant *initVal = DtoConstInitializer(loc, type, init); // In case of type mismatch, swap out the variable. if (initVal->getType() != gvar->getType()->getElementType()) { llvm::GlobalVariable* newGvar = getOrCreateGlobal(loc, *gIR->module, initVal->getType(), isLLConst, llLinkage, 0, "", // We take on the name of the old global below. isThreadlocal()); newGvar->takeName(gvar); llvm::Constant* newValue = llvm::ConstantExpr::getBitCast(newGvar, gvar->getType()); gvar->replaceAllUsesWith(newValue); gvar->eraseFromParent(); gvar = newGvar; this->ir.irGlobal->value = newGvar; } // Now, set the initializer. assert(!ir.irGlobal->constInit); ir.irGlobal->constInit = initVal; gvar->setInitializer(initVal); // Also set up the edbug info. DtoDwarfGlobalVariable(gvar, this); } // Set the alignment (it is important not to use type->alignsize because // VarDeclarations can have an align() attribute independent of the type // as well). if (alignment != STRUCTALIGN_DEFAULT) gvar->setAlignment(alignment); // If this global is used from a naked function, we need to create an // artificial "use" for it, or it could be removed by the optimizer if // the only reference to it is in inline asm. if (nakedUse) gIR->usedArray.push_back(DtoBitCast(gvar, getVoidPtrType())); if (Logger::enabled()) Logger::cout() << *gvar << '\n'; } }
// 'B' t void mangle(std::ostream& os, Block_type const* t) { os << 'B'; mangle(os, t->type()); }
void operator()(Module_decl const* d) { mangle(os, d); }
void operator()(Method_decl const* d) { mangle(os, d); }
void savedata(Sym *s, Prog *p, char *pn) { int32 off, siz, i, fl; uchar *cast; vlong o; Reloc *r; off = p->from.offset; siz = p->datasize; if(off < 0 || siz < 0 || off >= 1<<30 || siz >= 100) mangle(pn); symgrow(s, off+siz); switch(p->to.type) { default: diag("bad data: %P", p); break; case D_FCONST: switch(siz) { default: case 4: fl = ieeedtof(&p->to.ieee); cast = (uchar*)&fl; for(i=0; i<4; i++) s->p[off+i] = cast[fnuxi4[i]]; break; case 8: cast = (uchar*)&p->to.ieee; for(i=0; i<8; i++) s->p[off+i] = cast[fnuxi8[i]]; break; } break; case D_SCONST: for(i=0; i<siz; i++) s->p[off+i] = p->to.scon[i]; break; case D_CONST: if(p->to.sym) goto Addr; o = p->to.offset; fl = o; cast = (uchar*)&fl; switch(siz) { default: diag("bad nuxi %d\n%P", siz, p); break; case 1: s->p[off] = cast[inuxi1[0]]; break; case 2: for(i=0; i<2; i++) s->p[off+i] = cast[inuxi2[i]]; break; case 4: for(i=0; i<4; i++) s->p[off+i] = cast[inuxi4[i]]; break; case 8: cast = (uchar*)&o; for(i=0; i<8; i++) s->p[off+i] = cast[inuxi8[i]]; break; } break; case D_ADDR: case D_SIZE: Addr: r = addrel(s); r->off = off; r->siz = siz; r->sym = p->to.sym; r->type = p->to.type; if(r->type != D_SIZE) r->type = D_ADDR; r->add = p->to.offset; break; } }
llvm::GlobalVariable * IrAggr::getInterfaceVtbl(BaseClass * b, bool new_instance, size_t interfaces_index) { ClassGlobalMap::iterator it = interfaceVtblMap.find(b->base); if (it != interfaceVtblMap.end()) return it->second; IF_LOG Logger::println("Building vtbl for implementation of interface %s in class %s", b->base->toPrettyChars(), aggrdecl->toPrettyChars()); LOG_SCOPE; ClassDeclaration* cd = aggrdecl->isClassDeclaration(); assert(cd && "not a class aggregate"); FuncDeclarations vtbl_array; b->fillVtbl(cd, &vtbl_array, new_instance); std::vector<llvm::Constant*> constants; constants.reserve(vtbl_array.dim); if (!b->base->isCPPinterface()) { // skip interface info for CPP interfaces // start with the interface info VarDeclarationIter interfaces_idx(ClassDeclaration::classinfo->fields, 3); // index into the interfaces array llvm::Constant* idxs[2] = { DtoConstSize_t(0), DtoConstSize_t(interfaces_index) }; llvm::Constant* c = llvm::ConstantExpr::getGetElementPtr( getInterfaceArraySymbol(), idxs, true); constants.push_back(c); } // add virtual function pointers size_t n = vtbl_array.dim; for (size_t i = b->base->vtblOffset(); i < n; i++) { Dsymbol* dsym = static_cast<Dsymbol*>(vtbl_array.data[i]); if (dsym == NULL) { // FIXME // why is this null? // happens for mini/s.d constants.push_back(getNullValue(getVoidPtrType())); continue; } FuncDeclaration* fd = dsym->isFuncDeclaration(); assert(fd && "vtbl entry not a function"); assert((!fd->isAbstract() || fd->fbody) && "null symbol in interface implementation vtable"); fd->codegen(Type::sir); assert(fd->ir.irFunc && "invalid vtbl function"); LLFunction *fn = fd->ir.irFunc->func; // If the base is a cpp interface, 'this' parameter is a pointer to // the interface not the underlying object as expected. Instead of // the function, we place into the vtable a small wrapper, called thunk, // that casts 'this' to the object and then pass it to the real function. if (b->base->isCPPinterface()) { TypeFunction *f = (TypeFunction*)fd->type->toBasetype(); assert(f->fty.arg_this); // create the thunk function OutBuffer name; name.writestring("Th"); name.printf("%i", b->offset); name.writestring(fd->mangle()); LLFunction *thunk = LLFunction::Create(isaFunction(fn->getType()->getContainedType(0)), DtoLinkage(fd), name.toChars(), gIR->module); // create entry and end blocks llvm::BasicBlock* beginbb = llvm::BasicBlock::Create(gIR->context(), "entry", thunk); llvm::BasicBlock* endbb = llvm::BasicBlock::Create(gIR->context(), "endentry", thunk); gIR->scopes.push_back(IRScope(beginbb, endbb)); // copy the function parameters, so later we can pass them to the real function std::vector<LLValue*> args; llvm::Function::arg_iterator iarg = thunk->arg_begin(); for (; iarg != thunk->arg_end(); ++iarg) args.push_back(iarg); // cast 'this' to Object LLValue* &thisArg = args[(f->fty.arg_sret == 0) ? 0 : 1]; LLType* thisType = thisArg->getType(); thisArg = DtoBitCast(thisArg, getVoidPtrType()); thisArg = DtoGEP1(thisArg, DtoConstInt(-b->offset)); thisArg = DtoBitCast(thisArg, thisType); // call the real vtbl function. LLValue *retVal = gIR->ir->CreateCall(fn, args); // return from the thunk if (thunk->getReturnType() == LLType::getVoidTy(gIR->context())) llvm::ReturnInst::Create(gIR->context(), beginbb); else llvm::ReturnInst::Create(gIR->context(), retVal, beginbb); // clean up gIR->scopes.pop_back(); thunk->getBasicBlockList().pop_back(); fn = thunk; } constants.push_back(fn); } // build the vtbl constant llvm::Constant* vtbl_constant = LLConstantStruct::getAnon(gIR->context(), constants, false); // create the global variable to hold it llvm::GlobalValue::LinkageTypes _linkage = DtoExternalLinkage(aggrdecl); std::string mangle("_D"); mangle.append(cd->mangle()); mangle.append("11__interface"); mangle.append(b->base->mangle()); mangle.append("6__vtblZ"); llvm::GlobalVariable* GV = getOrCreateGlobal(cd->loc, *gIR->module, vtbl_constant->getType(), true, _linkage, vtbl_constant, mangle ); // insert into the vtbl map interfaceVtblMap.insert(std::make_pair(b->base, GV)); return GV; }
/****************************************************************************** * isv : for the enclosing auto functions of an inner class/struct type. * An aggregate type which defined inside auto function, it might * become Voldemort Type so its object might be returned. * This flag is necessary due to avoid mutual mangling * between return type and enclosing scope. See bugzilla 8847. */ char *mangle(Declaration *sthis, bool isv) { OutBuffer buf; char *id; Dsymbol *s; //printf("::mangle(%s)\n", sthis->toChars()); s = sthis; do { //printf("mangle: s = %p, '%s', parent = %p\n", s, s->toChars(), s->parent); if (s->ident) { FuncDeclaration *fd = s->isFuncDeclaration(); if (s != sthis && fd) { id = mangle(fd, isv); buf.prependstring(id); goto L1; } else { id = s->ident->toChars(); size_t len = strlen(id); char tmp[sizeof(len) * 3 + 1]; buf.prependstring(id); sprintf(tmp, "%d", (int)len); buf.prependstring(tmp); } } else buf.prependstring("0"); s = s->parent; } while (s); // buf.prependstring("_D"); L1: //printf("deco = '%s'\n", sthis->type->deco ? sthis->type->deco : "null"); //printf("sthis->type = %s\n", sthis->type->toChars()); FuncDeclaration *fd = sthis->isFuncDeclaration(); if (fd && (fd->needThis() || fd->isNested())) buf.writeByte(Type::needThisPrefix()); if (isv && fd && (fd->inferRetType || getFuncTemplateDecl(fd))) { TypeFunction tfn = *(TypeFunction *)sthis->type; TypeFunction *tfo = (TypeFunction *)sthis->originalType; tfn.purity = tfo->purity; tfn.isnothrow = tfo->isnothrow; tfn.isproperty = tfo->isproperty; tfn.isref = fd->storage_class & STCauto ? false : tfo->isref; tfn.trust = tfo->trust; tfn.next = NULL; // do not mangle return type tfn.toDecoBuffer(&buf, 0); } else if (sthis->type->deco) buf.writestring(sthis->type->deco); else { #ifdef DEBUG if (!fd->inferRetType) printf("%s\n", fd->toChars()); #endif assert(fd && fd->inferRetType); } id = buf.toChars(); buf.data = NULL; return id; }
static int installservice(char *account,char *pass) { SC_HANDLE service, scm; TCHAR path[512], system[80], name[80], username[80]; char userpass[256], user[256], dom[256]="."; int i,ret = 0; pid_t pid = -1; if(!GetModuleFileName(NULL, path, 512)) { logmsg(LOG_STDERR+LOG_SYSTEM+0, "Unable to get executable name"); return(0); } strcpy(name, account); if(!pass) pass = getpass("Password: "******"UWIN_CS%s", name); sfsprintf(servdname,sizeof(servdname),"UWIN Client(%s)", name); for(i=0;i<(signed)strlen(servname);i++) if(servname[i] == '/') servname[i]= '#'; if ((scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) != NULL) { if((service=OpenService(scm,TEXT(servname),SERVICE_QUERY_STATUS)) == NULL) { // If service does not exist then install. if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) { strcpy(user,name); if((sep = strchr(name,'/')) != NULL) { *sep = '\0'; strcpy(dom,name); strcpy(user,sep+1); *sep = '\\'; setuid(1); } if (system[0] != '\0') { sysname = system; } if (LookupAccountName(sysname,user,sid,&sidlen,domain,&domlen,&puse)) { if (verifylogin(user,dom,userpass)) { if ((pid = spawnl("/usr/etc/priv.exe","priv.exe",name,"1",0)) > 0) wait(&ret); ret = 0; strcat(dom,"\\"); strcat(dom,user); if ((service = CreateService(scm,servname,servdname,SERVICE_ALL_ACCESS,SERVICE_WIN32_OWN_PROCESS,SERVICE_DEMAND_START,SERVICE_ERROR_NORMAL,path,NULL,NULL,NULL,dom,userpass)) != NULL) { logmsg(LOG_STDERR+1, "%s installed", servdname); CloseServiceHandle(service); ret=1; } else error(LOG_ALL+1, "CreateService failed for user %s", name); } } else logerr(1, "Invalid UserName %s", username); } } else { CloseServiceHandle(service); ret = 1; } CloseServiceHandle(scm); } else error(1, "OpenSCManager failed"); } else logmsg(LOG_STDERR+0 ,"Invalid domain account %s", username); return(ret); }
/******************************************* * Convert intrinsic function to operator. * Returns that operator, -1 if not an intrinsic function. */ int intrinsic_op(FuncDeclaration *fd) { #if TX86 fd = fd->toAliasFunc(); const char *name = mangleExact(fd); //printf("intrinsic_op(%s)\n", name); static const char *std_namearray[] = { /* The names are mangled differently because of the pure and * nothrow attributes. */ "4math3cosFNaNbNiNfeZe", "4math3sinFNaNbNiNfeZe", "4math4fabsFNaNbNiNfeZe", "4math4rintFNaNbNiNfeZe", "4math4sqrtFNaNbNiNfdZd", "4math4sqrtFNaNbNiNfeZe", "4math4sqrtFNaNbNiNffZf", "4math4yl2xFNaNbNiNfeeZe", "4math5ldexpFNaNbNiNfeiZe", "4math6rndtolFNaNbNiNfeZl", "4math6yl2xp1FNaNbNiNfeeZe", }; static const char *std_namearray64[] = { /* The names are mangled differently because of the pure and * nothrow attributes. */ "4math3cosFNaNbNiNfeZe", "4math3sinFNaNbNiNfeZe", "4math4fabsFNaNbNiNfeZe", "4math4rintFNaNbNiNfeZe", "4math4sqrtFNaNbNiNfdZd", "4math4sqrtFNaNbNiNfeZe", "4math4sqrtFNaNbNiNffZf", "4math4yl2xFNaNbNiNfeeZe", "4math5ldexpFNaNbNiNfeiZe", "4math6rndtolFNaNbNiNfeZl", "4math6yl2xp1FNaNbNiNfeeZe", }; static unsigned char std_ioptab[] = { OPcos, OPsin, OPabs, OPrint, OPsqrt, OPsqrt, OPsqrt, OPyl2x, OPscale, OPrndtol, OPyl2xp1, }; static const char *core_namearray[] = { "4math3cosFNaNbNiNfeZe", "4math3sinFNaNbNiNfeZe", "4math4fabsFNaNbNiNfeZe", "4math4rintFNaNbNiNfeZe", "4math4sqrtFNaNbNiNfdZd", "4math4sqrtFNaNbNiNfeZe", "4math4sqrtFNaNbNiNffZf", "4math4yl2xFNaNbNiNfeeZe", "4math5ldexpFNaNbNiNfeiZe", "4math6rndtolFNaNbNiNfeZl", "4math6yl2xp1FNaNbNiNfeeZe", "4simd10__simd_stoFNaNbNiNfE4core4simd3XMMNhG16vNhG16vZNhG16v", "4simd10__simd_stoFNaNbNiNfE4core4simd3XMMdNhG16vZNhG16v", "4simd10__simd_stoFNaNbNiNfE4core4simd3XMMfNhG16vZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMNhG16vNhG16vZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMNhG16vNhG16vhZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMNhG16vZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMdZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMfZNhG16v", "4simd9__simd_ibFNaNbNiNfE4core4simd3XMMNhG16vhZNhG16v", "5bitop12volatileLoadFNbNiNfPhZh", "5bitop12volatileLoadFNbNiNfPkZk", "5bitop12volatileLoadFNbNiNfPmZm", "5bitop12volatileLoadFNbNiNfPtZt", "5bitop13volatileStoreFNbNiNfPhhZv", "5bitop13volatileStoreFNbNiNfPkkZv", "5bitop13volatileStoreFNbNiNfPmmZv", "5bitop13volatileStoreFNbNiNfPttZv", "5bitop3bsfFNaNbNiNfkZi", "5bitop3bsrFNaNbNiNfkZi", "5bitop3btcFNaNbNiPkkZi", "5bitop3btrFNaNbNiPkkZi", "5bitop3btsFNaNbNiPkkZi", "5bitop3inpFNbNikZh", "5bitop4inplFNbNikZk", "5bitop4inpwFNbNikZt", "5bitop4outpFNbNikhZh", "5bitop5bswapFNaNbNiNfkZk", "5bitop5outplFNbNikkZk", "5bitop5outpwFNbNiktZt", "5bitop7_popcntFNaNbNiNfkZi", "5bitop7_popcntFNaNbNiNfmxx", // don't find 64 bit version in 32 bit code "5bitop7_popcntFNaNbNiNftZt", }; static const char *core_namearray64[] = { "4math3cosFNaNbNiNfeZe", "4math3sinFNaNbNiNfeZe", "4math4fabsFNaNbNiNfeZe", "4math4rintFNaNbNiNfeZe", "4math4sqrtFNaNbNiNfdZd", "4math4sqrtFNaNbNiNfeZe", "4math4sqrtFNaNbNiNffZf", "4math4yl2xFNaNbNiNfeeZe", "4math5ldexpFNaNbNiNfeiZe", "4math6rndtolFNaNbNiNfeZl", "4math6yl2xp1FNaNbNiNfeeZe", "4simd10__simd_stoFNaNbNiNfE4core4simd3XMMNhG16vNhG16vZNhG16v", "4simd10__simd_stoFNaNbNiNfE4core4simd3XMMdNhG16vZNhG16v", "4simd10__simd_stoFNaNbNiNfE4core4simd3XMMfNhG16vZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMNhG16vNhG16vZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMNhG16vNhG16vhZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMNhG16vZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMdZNhG16v", "4simd6__simdFNaNbNiNfE4core4simd3XMMfZNhG16v", "4simd9__simd_ibFNaNbNiNfE4core4simd3XMMNhG16vhZNhG16v", "5bitop12volatileLoadFNbNiNfPhZh", "5bitop12volatileLoadFNbNiNfPkZk", "5bitop12volatileLoadFNbNiNfPmZm", "5bitop12volatileLoadFNbNiNfPtZt", "5bitop13volatileStoreFNbNiNfPhhZv", "5bitop13volatileStoreFNbNiNfPkkZv", "5bitop13volatileStoreFNbNiNfPmmZv", "5bitop13volatileStoreFNbNiNfPttZv", "5bitop3bsfFNaNbNiNfmZi", "5bitop3bsrFNaNbNiNfmZi", "5bitop3btcFNaNbNiPmmZi", "5bitop3btrFNaNbNiPmmZi", "5bitop3btsFNaNbNiPmmZi", "5bitop3inpFNbNikZh", "5bitop4inplFNbNikZk", "5bitop4inpwFNbNikZt", "5bitop4outpFNbNikhZh", "5bitop5bswapFNaNbNiNfkZk", "5bitop5outplFNbNikkZk", "5bitop5outpwFNbNiktZt", "5bitop7_popcntFNaNbNiNfkZi", "5bitop7_popcntFNaNbNiNfmZi", "5bitop7_popcntFNaNbNiNftZt", }; static unsigned char core_ioptab[] = { OPcos, OPsin, OPabs, OPrint, OPsqrt, OPsqrt, OPsqrt, OPyl2x, OPscale, OPrndtol, OPyl2xp1, OPvector, OPvector, OPvector, OPvector, OPvector, OPvector, OPvector, OPvector, OPvector, OPind, OPind, OPind, OPind, OPeq, OPeq, OPeq, OPeq, OPbsf, OPbsr, OPbtc, OPbtr, OPbts, OPinp, OPinp, OPinp, OPoutp, OPbswap, OPoutp, OPoutp, OPpopcnt, OPpopcnt, OPpopcnt, }; #ifdef DEBUG assert(sizeof(std_namearray) == sizeof(std_namearray64)); assert(sizeof(std_namearray) / sizeof(char *) == sizeof(std_ioptab)); for (size_t i = 0; i < sizeof(std_namearray) / sizeof(char *) - 1; i++) { if (strcmp(std_namearray[i], std_namearray[i + 1]) >= 0) { printf("std_namearray[%ld] = '%s'\n", (long)i, std_namearray[i]); assert(0); } } assert(sizeof(std_namearray64) / sizeof(char *) == sizeof(std_ioptab)); for (size_t i = 0; i < sizeof(std_namearray64) / sizeof(char *) - 1; i++) { if (strcmp(std_namearray64[i], std_namearray64[i + 1]) >= 0) { printf("std_namearray64[%ld] = '%s'\n", (long)i, std_namearray64[i]); assert(0); } } assert(sizeof(core_namearray) == sizeof(core_namearray64)); assert(sizeof(core_namearray) / sizeof(char *) == sizeof(core_ioptab)); for (size_t i = 0; i < sizeof(core_namearray) / sizeof(char *) - 1; i++) { //printf("test1 %s %s %d\n", core_namearray[i], core_namearray[i + 1], strcmp(core_namearray[i], core_namearray[i + 1])); if (strcmp(core_namearray[i], core_namearray[i + 1]) >= 0) { printf("core_namearray[%ld] = '%s'\n", (long)i, core_namearray[i]); assert(0); } } assert(sizeof(core_namearray64) / sizeof(char *) == sizeof(core_ioptab)); for (size_t i = 0; i < sizeof(core_namearray64) / sizeof(char *) - 1; i++) { if (strcmp(core_namearray64[i], core_namearray64[i + 1]) >= 0) { printf("core_namearray64[%ld] = '%s'\n", (long)i, core_namearray64[i]); assert(0); } } #endif size_t length = strlen(name); if (length > 10 && (name[7] == 'm' || name[7] == 'i') && !memcmp(name, "_D3std", 6)) { int i = binary(name + 6, I64 ? std_namearray64 : std_namearray, sizeof(std_namearray) / sizeof(char *)); return (i == -1) ? i : std_ioptab[i]; } if (length > 12 && (name[8] == 'm' || name[8] == 'b' || name[8] == 's') && !memcmp(name, "_D4core", 7)) { int i = binary(name + 7, I64 ? core_namearray64 : core_namearray, sizeof(core_namearray) / sizeof(char *)); if (i != -1) return core_ioptab[i]; if (global.params.is64bit && fd->toParent()->isTemplateInstance() && !strcmp(mangle(fd->getModule()), "4core4stdc6stdarg") && fd->ident == Id::va_start) { return OPva_start; } return -1; } #endif return -1; }
/***************************************************************************** * do the actual mangling to 8.3 format * the buffer must be able to hold 13 characters (including the null) ***************************************************************************** */ void mangle_name_83(char *s) { int crc16, i; char *p, *q; char extension[4]; char base[9]; int baselen = 0; int extlen = 0; extension[0] = 0; base[0] = 0; /* * First, convert some common Unix extensions to extensions of 3 * characters. If none fits, don't change anything now. */ if (strcmp(q = s + strlen(s) - strlen(".tar.gz"), ".tar.gz") == 0) { *q = '\0'; q = (char *)"tgz"; } else if (strcmp(q = s + strlen(s) - strlen(".tar.z"), ".tar.z") == 0) { *q = '\0'; q = (char *)"tgz"; } else if (strcmp(q = s + strlen(s) - strlen(".tar.Z"), ".tar.Z") == 0) { *q = '\0'; q = (char *)"taz"; } else if (strcmp(q = s + strlen(s) - strlen(".html"), ".html") == 0) { *q = '\0'; q = (char *)"htm"; } else if (strcmp(q = s + strlen(s) - strlen(".shtml"), ".shtml") == 0) { *q = '\0'; q = (char *)"stm"; } else if (strcmp(q = s + strlen(s) - strlen(".conf"), ".conf") == 0) { *q = '\0'; q = (char *)"cnf"; } else if (strcmp(q = s + strlen(s) - strlen(".mpeg"), ".mpeg") == 0) { *q = '\0'; q = (char *)"mpg"; } else if (strcmp(q = s + strlen(s) - strlen(".smil"), ".smil") == 0) { *q = '\0'; q = (char *)"smi"; } else if (strcmp(q = s + strlen(s) - strlen(".perl"), ".perl") == 0) { *q = '\0'; q = (char *)"pl"; } else if (strcmp(q = s + strlen(s) - strlen(".jpeg"), ".jpeg") == 0) { *q = '\0'; q = (char *)"jpg"; } else if (strcmp(q = s + strlen(s) - strlen(".tiff"), ".tiff") == 0) { *q = '\0'; q = (char *)"tif"; } else { q = NULL; } if (q) { /* * Extension is modified, apply changes */ p = s + strlen(s); *p++ = '.'; for (i = 0; i < strlen(q); i++) *p++ = q[i]; *p++ = '\0'; } /* * Now start name mangling */ p = strrchr(s,'.'); if (p && (strlen(p+1) < (size_t)4)) { int all_normal = (!strhaslower(p+1)); /* XXXXXXXXX */ if (all_normal && p[1] != 0) { *p = 0; crc16 = crc16xmodem(s, strlen(s)); *p = '.'; } else { crc16 = crc16xmodem(s, strlen(s)); } } else { crc16 = crc16xmodem(s, strlen(s)); } tu(s); if (p) { if (p == s) safe_strcpy(extension, "___", 3); else { *p++ = 0; while (*p && extlen < 3) { if (*p != '.' ) extension[extlen++] = p[0]; p++; } extension[extlen] = 0; } } p = s; /* * Changed to baselen 4, original this is 5. * 24-11-2002 MB. */ while (*p && baselen < 4) { if (*p != '.' ) base[baselen++] = p[0]; p++; } base[baselen] = 0; if (crc16 > (MANGLE_BASE * MANGLE_BASE * MANGLE_BASE)) Syslog('!', "WARNING: mangle_name_83() crc16 overflow"); crc16 = crc16 % (MANGLE_BASE * MANGLE_BASE * MANGLE_BASE); snprintf(s, 9, "%s%c%c%c%c", base, magic_char, mangle(crc16 / (MANGLE_BASE * MANGLE_BASE)), mangle(crc16 / MANGLE_BASE), mangle(crc16)); if ( *extension ) { (void)strcat(s, "."); (void)strcat(s, extension); } }
static int checkfs(const char *vfst, const char *spec, const char *mntpt, void *auxarg, pid_t *pidp) { /* List of directories containing fsck_xxx subcommands. */ static const char *edirs[] = { #ifdef RESCUEDIR RESCUEDIR, #endif _PATH_SBIN, _PATH_USRSBIN, NULL }; const char ** volatile argv, **edir; const char * volatile vfstype = vfst; pid_t pid; int argc, i, status, maxargc; char *optb; char *volatile optbuf; char execname[MAXPATHLEN + 1], execbase[MAXPATHLEN]; const char *extra = getoptions(vfstype); if (!strcmp(vfstype, "ufs")) vfstype = MOUNT_UFS; optb = NULL; if (options) catopt(&optb, options); if (extra) catopt(&optb, extra); optbuf = optb; maxargc = 64; argv = emalloc(sizeof(char *) * maxargc); (void) snprintf(execbase, sizeof(execbase), "fsck_%s", vfstype); argc = 0; argv[argc++] = execbase; if (optbuf) mangle(optbuf, &argc, &argv, &maxargc); argv[argc++] = spec; argv[argc] = NULL; if (flags & (CHECK_DEBUG|CHECK_VERBOSE)) { (void)printf("start %s %swait", mntpt, pidp ? "no" : ""); for (i = 0; i < argc; i++) (void)printf(" %s", argv[i]); (void)printf("\n"); } switch (pid = vfork()) { case -1: /* Error. */ warn("vfork"); if (optbuf) free(optbuf); free(argv); return FSCK_EXIT_CHECK_FAILED; case 0: /* Child. */ if ((flags & CHECK_FORCE) == 0) { struct statvfs sfs; /* * if mntpt is a mountpoint of a mounted file * system and it's mounted read-write, skip it * unless -f is given. */ if ((statvfs(mntpt, &sfs) == 0) && (strcmp(mntpt, sfs.f_mntonname) == 0) && ((sfs.f_flag & MNT_RDONLY) == 0)) { printf( "%s: file system is mounted read-write on %s; not checking\n", spec, mntpt); if ((flags & CHECK_PREEN) && auxarg != NULL) _exit(FSCK_EXIT_OK); /* fsck -p */ else _exit(FSCK_EXIT_CHECK_FAILED); /* fsck [[-p] ...] */ } } if (flags & CHECK_DEBUG) _exit(FSCK_EXIT_OK); /* Go find an executable. */ edir = edirs; do { (void)snprintf(execname, sizeof(execname), "%s/%s", *edir, execbase); execv(execname, (char * const *)__UNCONST(argv)); if (errno != ENOENT) { if (spec) warn("exec %s for %s", execname, spec); else warn("exec %s", execname); } } while (*++edir != NULL); if (errno == ENOENT) { if (spec) warn("exec %s for %s", execname, spec); else warn("exec %s", execname); } _exit(FSCK_EXIT_CHECK_FAILED); /* NOTREACHED */ default: /* Parent. */ if (optbuf) free(optbuf); free(argv); if (pidp) { *pidp = pid; return FSCK_EXIT_OK; } if (waitpid(pid, &status, 0) < 0) { warn("waitpid"); return FSCK_EXIT_CHECK_FAILED; } if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return WEXITSTATUS(status); } else if (WIFSIGNALED(status)) { warnx("%s: %s", spec, strsignal(WTERMSIG(status))); return FSCK_EXIT_CHECK_FAILED; } break; } return FSCK_EXIT_OK; }
static int show_vfsmnt(struct seq_file *m, struct vfsmount *mnt) { struct mount *r = real_mount(mnt); int err = 0; struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt }; struct super_block *sb = mnt_path.dentry->d_sb; if (sb->s_op->show_devname) { err = sb->s_op->show_devname(m, mnt_path.dentry); if (err) goto out; } else { mangle(m, r->mnt_devname ? r->mnt_devname : "none"); } seq_putc(m, ' '); seq_path(m, &mnt_path, " \t\n\\"); seq_putc(m, ' '); show_type(m, sb); seq_puts(m, __mnt_is_readonly(mnt) ? " ro" : " rw"); err = show_sb_opts(m, sb); if (err) goto out; show_mnt_opts(m, mnt); if (sb->s_op->show_options) err = sb->s_op->show_options(m, mnt_path.dentry); seq_puts(m, " 0 0\n"); out: return err; } static int show_mountinfo(struct seq_file *m, struct vfsmount *mnt) { struct proc_mounts *p = proc_mounts(m); struct mount *r = real_mount(mnt); struct super_block *sb = mnt->mnt_sb; struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt }; struct path root = p->root; int err = 0; seq_printf(m, "%i %i %u:%u ", r->mnt_id, r->mnt_parent->mnt_id, MAJOR(sb->s_dev), MINOR(sb->s_dev)); if (sb->s_op->show_path) err = sb->s_op->show_path(m, mnt->mnt_root); else seq_dentry(m, mnt->mnt_root, " \t\n\\"); if (err) goto out; seq_putc(m, ' '); /* mountpoints outside of chroot jail will give SEQ_SKIP on this */ err = seq_path_root(m, &mnt_path, &root, " \t\n\\"); if (err) goto out; seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw"); show_mnt_opts(m, mnt); /* Tagged fields ("foo:X" or "bar") */ if (IS_MNT_SHARED(r)) seq_printf(m, " shared:%i", r->mnt_group_id); if (IS_MNT_SLAVE(r)) { int master = r->mnt_master->mnt_group_id; int dom = get_dominating_id(r, &p->root); seq_printf(m, " master:%i", master); if (dom && dom != master) seq_printf(m, " propagate_from:%i", dom); } if (IS_MNT_UNBINDABLE(r)) seq_puts(m, " unbindable"); /* Filesystem specific data */ seq_puts(m, " - "); show_type(m, sb); seq_putc(m, ' '); if (sb->s_op->show_devname) err = sb->s_op->show_devname(m, mnt->mnt_root); else mangle(m, r->mnt_devname ? r->mnt_devname : "none"); if (err) goto out; seq_puts(m, sb->s_flags & MS_RDONLY ? " ro" : " rw"); err = show_sb_opts(m, sb); if (err) goto out; if (sb->s_op->show_options) err = sb->s_op->show_options(m, mnt->mnt_root); seq_putc(m, '\n'); out: return err; } static int show_vfsstat(struct seq_file *m, struct vfsmount *mnt) { struct mount *r = real_mount(mnt); struct path mnt_path = { .dentry = mnt->mnt_root, .mnt = mnt }; struct super_block *sb = mnt_path.dentry->d_sb; int err = 0; /* device */ if (sb->s_op->show_devname) { seq_puts(m, "device "); err = sb->s_op->show_devname(m, mnt_path.dentry); } else { if (r->mnt_devname) { seq_puts(m, "device "); mangle(m, r->mnt_devname); } else seq_puts(m, "no device"); } /* mount point */ seq_puts(m, " mounted on "); seq_path(m, &mnt_path, " \t\n\\"); seq_putc(m, ' '); /* file system type */ seq_puts(m, "with fstype "); show_type(m, sb); /* optional statistics */ if (sb->s_op->show_stats) { seq_putc(m, ' '); if (!err) err = sb->s_op->show_stats(m, mnt_path.dentry); } seq_putc(m, '\n'); return err; } static int mounts_open_common(struct inode *inode, struct file *file, int (*show)(struct seq_file *, struct vfsmount *)) { struct task_struct *task = get_proc_task(inode); struct nsproxy *nsp; struct mnt_namespace *ns = NULL; struct path root; struct proc_mounts *p; int ret = -EINVAL; if (!task) goto err; task_lock(task); nsp = task->nsproxy; if (!nsp || !nsp->mnt_ns) { task_unlock(task); put_task_struct(task); goto err; } ns = nsp->mnt_ns; get_mnt_ns(ns); if (!task->fs) { task_unlock(task); put_task_struct(task); ret = -ENOENT; goto err_put_ns; } get_fs_root(task->fs, &root); task_unlock(task); put_task_struct(task); ret = -ENOMEM; p = kmalloc(sizeof(struct proc_mounts), GFP_KERNEL); if (!p) goto err_put_path; file->private_data = &p->m; ret = seq_open(file, &mounts_op); if (ret) goto err_free; p->ns = ns; p->root = root; p->m.poll_event = ns->event; p->show = show; return 0; err_free: kfree(p); err_put_path: path_put(&root); err_put_ns: put_mnt_ns(ns); err: return ret; } static int mounts_release(struct inode *inode, struct file *file) { struct proc_mounts *p = proc_mounts(file->private_data); path_put(&p->root); put_mnt_ns(p->ns); return seq_release(inode, file); } static int mounts_open(struct inode *inode, struct file *file) { return mounts_open_common(inode, file, show_vfsmnt); } static int mountinfo_open(struct inode *inode, struct file *file) { return mounts_open_common(inode, file, show_mountinfo); } static int mountstats_open(struct inode *inode, struct file *file) { return mounts_open_common(inode, file, show_vfsstat); } const struct file_operations proc_mounts_operations = { .open = mounts_open, .read = seq_read, .llseek = seq_lseek, .release = mounts_release, .poll = mounts_poll, }; const struct file_operations proc_mountinfo_operations = { .open = mountinfo_open, .read = seq_read, .llseek = seq_lseek, .release = mounts_release, .poll = mounts_poll, }; const struct file_operations proc_mountstats_operations = { .open = mountstats_open, .read = seq_read, .llseek = seq_lseek, .release = mounts_release, };
void visit(VarDeclaration *vd) { //printf("VarDeclaration::toSymbol(%s)\n", vd->toChars()); assert(!vd->needThis()); if (!vd->csym) { const char *id; if (vd->isDataseg()) id = mangle(vd); else id = vd->ident->toChars(); Symbol *s = symbol_calloc(id); s->Salignment = vd->alignment; if (vd->storage_class & STCtemp) s->Sflags |= SFLartifical; TYPE *t; if (vd->storage_class & (STCout | STCref)) { // should be TYref, but problems in back end t = type_pointer(Type_toCtype(vd->type)); } else if (vd->storage_class & STClazy) { if (config.exe == EX_WIN64 && vd->isParameter()) t = type_fake(TYnptr); else t = type_fake(TYdelegate); // Tdelegate as C type t->Tcount++; } else if (vd->isParameter()) { if (config.exe == EX_WIN64 && vd->type->size(Loc()) > REGSIZE) { // should be TYref, but problems in back end t = type_pointer(Type_toCtype(vd->type)); } else { t = Type_toCtype(vd->type); t->Tcount++; } } else { t = Type_toCtype(vd->type); t->Tcount++; } if (vd->isDataseg()) { if (vd->isThreadlocal()) { /* Thread local storage */ TYPE *ts = t; ts->Tcount++; // make sure a different t is allocated type_setty(&t, t->Tty | mTYthread); ts->Tcount--; if (global.params.vtls) { char *p = vd->loc.toChars(); fprintf(global.stdmsg, "%s: %s is thread local\n", p ? p : "", vd->toChars()); if (p) mem.free(p); } } s->Sclass = SCextern; s->Sfl = FLextern; slist_add(s); /* if it's global or static, then it needs to have a qualified but unmangled name. * This gives some explanation of the separation in treating name mangling. * It applies to PDB format, but should apply to CV as PDB derives from CV. * http://msdn.microsoft.com/en-us/library/ff553493(VS.85).aspx */ s->prettyIdent = vd->toPrettyChars(); } else { s->Sclass = SCauto; s->Sfl = FLauto; if (vd->nestedrefs.dim) { /* Symbol is accessed by a nested function. Make sure * it is not put in a register, and that the optimizer * assumes it is modified across function calls and pointer * dereferences. */ //printf("\tnested ref, not register\n"); type_setcv(&t, t->Tty | mTYvolatile); } } if (vd->ident == Id::va_argsave) { /* __va_argsave is set outside of the realm of the optimizer, * so we tell the optimizer to leave it alone */ type_setcv(&t, t->Tty | mTYvolatile); } mangle_t m = 0; switch (vd->linkage) { case LINKwindows: m = global.params.is64bit ? mTYman_c : mTYman_std; break; case LINKpascal: m = mTYman_pas; break; case LINKc: m = mTYman_c; break; case LINKd: m = mTYman_d; break; case LINKcpp: s->Sflags |= SFLpublic; m = mTYman_d; break; default: printf("linkage = %d\n", vd->linkage); assert(0); } type_setmangle(&t, m); s->Stype = t; vd->csym = s; } result = vd->csym; }
static llvm::Function *build_module_unittest(Module *m) { std::string name("_D"); name.append(mangle(m)); name.append("10__unittestZ"); return build_module_function(name, getIrModule(m)->unitTests); }
static bool to_8_3(char magic_char, const char *in, char out[13], int default_case) { int csum; char *p; char extension[4]; char base[9]; int baselen = 0; int extlen = 0; char *s = SMB_STRDUP(in); extension[0] = 0; base[0] = 0; if (!s) { return False; } p = strrchr(s,'.'); if( p && (strlen(p+1) < (size_t)4) ) { bool all_normal = ( strisnormal(p+1, default_case) ); /* XXXXXXXXX */ if( all_normal && p[1] != 0 ) { *p = 0; csum = str_checksum( s ); *p = '.'; } else csum = str_checksum(s); } else csum = str_checksum(s); if (!strupper_m( s )) { SAFE_FREE(s); return false; } if( p ) { if( p == s ) strlcpy( extension, "___", 4); else { *p++ = 0; while( *p && extlen < 3 ) { if ( *p != '.') { extension[extlen++] = p[0]; } p++; } extension[extlen] = 0; } } p = s; while( *p && baselen < 5 ) { if (isbasechar(*p)) { base[baselen++] = p[0]; } p++; } base[baselen] = 0; csum = csum % (MANGLE_BASE*MANGLE_BASE); memcpy(out, base, baselen); out[baselen] = magic_char; out[baselen+1] = mangle( csum/MANGLE_BASE ); out[baselen+2] = mangle( csum ); if( *extension ) { out[baselen+3] = '.'; strlcpy(&out[baselen+4], extension, 4); } SAFE_FREE(s); return True; }
static llvm::Function *build_module_shared_dtor(Module *m) { std::string name("_D"); name.append(mangle(m)); name.append("13__shared_dtorZ"); return build_module_function(name, getIrModule(m)->sharedDtors); }
Symbol *FuncDeclaration::toSymbol() { if (!csym) { Symbol *s; TYPE *t; const char *id; #if 0 id = ident->toChars(); #else id = mangle(); #endif //printf("FuncDeclaration::toSymbol(%s %s)\n", kind(), toChars()); //printf("\tid = '%s'\n", id); //printf("\ttype = %s\n", type->toChars()); s = symbol_calloc(id); slist_add(s); { s->prettyIdent = toPrettyChars(); s->Sclass = SCglobal; symbol_func(s); func_t *f = s->Sfunc; if (isVirtual()) f->Fflags |= Fvirtual; else if (isMember2()) f->Fflags |= Fstatic; f->Fstartline.Slinnum = loc.linnum; f->Fstartline.Sfilename = (char *)loc.filename; if (endloc.linnum) { f->Fendline.Slinnum = endloc.linnum; f->Fendline.Sfilename = (char *)endloc.filename; } else { f->Fendline.Slinnum = loc.linnum; f->Fendline.Sfilename = (char *)loc.filename; } t = type->toCtype(); } mangle_t msave = t->Tmangle; if (isMain()) { t->Tty = TYnfunc; t->Tmangle = mTYman_c; } else { switch (linkage) { case LINKwindows: t->Tmangle = mTYman_std; break; case LINKpascal: t->Tty = TYnpfunc; t->Tmangle = mTYman_pas; break; case LINKc: t->Tmangle = mTYman_c; break; case LINKd: t->Tmangle = mTYman_d; break; case LINKcpp: t->Tmangle = mTYman_cpp; break; default: printf("linkage = %d\n", linkage); assert(0); } } if (msave) assert(msave == t->Tmangle); //printf("Tty = %x, mangle = x%x\n", t->Tty, t->Tmangle); t->Tcount++; s->Stype = t; //s->Sfielddef = this; csym = s; } return csym; }
static int checkfs(const char *vfstype, const char *spec, const char *mntpt, void *auxarg, pid_t *pidp) { /* List of directories containing fsck_xxx subcommands. */ static const char *edirs[] = { _PATH_SBIN, _PATH_USRSBIN, NULL }; const char **argv, **edir; pid_t pid; int argc, i, status, maxargc; char *optbuf = NULL, fsname[MAXPATHLEN], execname[MAXPATHLEN]; const char *extra = getoptions(vfstype); if (strcmp(vfstype, "ufs") == 0) vfstype = MOUNT_UFS; maxargc = 100; argv = emalloc(sizeof(char *) * maxargc); argc = 0; (void)snprintf(fsname, sizeof(fsname), "fsck_%s", vfstype); argv[argc++] = fsname; if (options) { if (extra != NULL) optbuf = catopt(options, extra, 0); else optbuf = estrdup(options); } else if (extra) optbuf = estrdup(extra); if (optbuf) mangle(optbuf, &argc, &argv, &maxargc); argv[argc++] = spec; argv[argc] = NULL; if (flags & (CHECK_DEBUG|CHECK_VERBOSE)) { (void)printf("start %s %swait %s", mntpt, pidp ? "no" : "", fsname); for (i = 1; i < argc; i++) (void)printf(" %s", argv[i]); (void)printf("\n"); } switch (pid = fork()) { case -1: /* Error. */ warn("fork"); if (optbuf) free(optbuf); free(argv); return (1); case 0: /* Child. */ if (flags & CHECK_DEBUG) _exit(0); /* Go find an executable. */ edir = edirs; do { (void)snprintf(execname, sizeof(execname), "%s/fsck_%s", *edir, vfstype); execv(execname, (char * const *)argv); if (errno != ENOENT) { if (spec) warn("exec %s for %s", execname, spec); else warn("exec %s", execname); } } while (*++edir != NULL); if (errno == ENOENT) { if (spec) warn("exec %s for %s", execname, spec); else warn("exec %s", execname); } exit(1); /* NOTREACHED */ default: /* Parent. */ if (optbuf) free(optbuf); free(argv); if (pidp) { *pidp = pid; return 0; } if (waitpid(pid, &status, 0) < 0) { warn("waitpid"); return (1); } if (WIFEXITED(status)) { if (WEXITSTATUS(status) != 0) return (WEXITSTATUS(status)); } else if (WIFSIGNALED(status)) { warnx("%s: %s", spec, strsignal(WTERMSIG(status))); return (1); } break; } return (0); }
/** * mnt_mangle: * @str: string * * Encode @str to be compatible with fstab/mtab * * Returns: new allocated string or NULL in case of error. */ char *mnt_mangle(const char *str) { return mangle(str); }
void operator()(Record_decl const* d) { mangle(os, d); }