void visit(WithStatement *s) { Symbol *sp; elem *e; elem *ei; ExpInitializer *ie; Blockx *blx = irs->blx; //printf("WithStatement::toIR()\n"); if (s->exp->op == TOKimport || s->exp->op == TOKtype) { } else { // Declare with handle sp = toSymbol(s->wthis); symbol_add(sp); // Perform initialization of with handle ie = s->wthis->_init->isExpInitializer(); assert(ie); ei = toElemDtor(ie->exp, irs); e = el_var(sp); e = el_bin(OPeq,e->Ety, e, ei); elem_setLoc(e, s->loc); incUsage(irs, s->loc); block_appendexp(blx->curblock,e); } // Execute with block if (s->_body) Statement_toIR(s->_body, irs); }
Element* TextBase::drop(EditData& ed) { TextCursor* _cursor = cursor(ed); Element* e = ed.element; switch (e->type()) { case ElementType::SYMBOL: { SymId id = toSymbol(e)->sym(); delete e; deleteSelectedText(ed); insertSym(ed, id); } break; case ElementType::FSYMBOL: { uint code = toFSymbol(e)->code(); delete e; QString s = QString::fromUcs4(&code, 1); deleteSelectedText(ed); score()->undo(new InsertText(_cursor, s), &ed); } break; default: break; } return 0; }
/************************************** * Given an expression e that is an array, * determine and set the 'length' variable. * Input: * lengthVar Symbol of 'length' variable * &e expression that is the array * t1 Type of the array * Output: * e is rewritten to avoid side effects * Returns: * expression that initializes 'length' */ elem *resolveLengthVar(VarDeclaration *lengthVar, elem **pe, Type *t1) { //printf("resolveLengthVar()\n"); elem *einit = NULL; if (lengthVar && !(lengthVar->storage_class & STCconst)) { elem *elength; Symbol *slength; if (t1->ty == Tsarray) { TypeSArray *tsa = (TypeSArray *)t1; dinteger_t length = tsa->dim->toInteger(); elength = el_long(TYsize_t, length); goto L3; } else if (t1->ty == Tarray) { elength = *pe; *pe = el_same(&elength); elength = el_una(I64 ? OP128_64 : OP64_32, TYsize_t, elength); L3: slength = toSymbol(lengthVar); //symbol_add(slength); einit = el_bin(OPeq, TYsize_t, el_var(slength), elength); } } return einit; }
UseStmt::UseStmt(BaseAST* source, std::vector<const char*>* args, bool exclude, std::map<const char*, const char*>* renames) : Stmt(E_UseStmt), src(NULL), named(), renamed(), except(exclude), relatedNames() { if (Symbol* b = toSymbol(source)) { src = new SymExpr(b); } else if (Expr* b = toExpr(source)) { src = b; } else { INT_FATAL(this, "Bad mod in UseStmt constructor"); } if (args->size() > 0) { // Symbols to search when going through this module's scope from an outside // scope for_vector(const char, str, *args) { named.push_back(str); } }
void visit(TypeInfoDeclaration *tid) { //printf("TypeInfoDeclaration::toObjFile(%p '%s') protection %d\n", tid, tid->toChars(), tid->protection); if (multiobj) { obj_append(tid); return; } Symbol *s = toSymbol(tid); s->Sclass = SCcomdat; s->Sfl = FLdata; TypeInfo_toDt(&s->Sdt, tid); dt_optimize(s->Sdt); // See if we can convert a comdat to a comdef, // which saves on exe file space. if (s->Sclass == SCcomdat && dtallzeros(s->Sdt)) { s->Sclass = SCglobal; dt2common(&s->Sdt); } outdata(s); if (tid->isExport()) objmod->export_symbol(s, 0); }
void Expr::verify() { if (prev || next) if (!list) INT_FATAL(this, "Expr is in list but does not point at it"); if (prev && prev->next != this) INT_FATAL(this, "Bad Expr->prev->next"); if (next && next->prev != this) INT_FATAL(this, "Bad Expr->next->prev"); if (!parentSymbol) INT_FATAL(this, "Expr::parentSymbol is NULL"); if (parentExpr && parentExpr->parentSymbol != parentSymbol) INT_FATAL(this, "Bad Expr::parentSymbol"); if (list && parentExpr && list->parent != parentExpr) INT_FATAL(this, "Bad Expr::list::parent"); if (list && !parentExpr) { if (Symbol* lps = toSymbol(list->parent)) if (lps != parentSymbol) INT_FATAL(this, "Bad symbol Expr::list::parent"); if (Type* lpt = toType(list->parent)) if (lpt->symbol != parentSymbol) INT_FATAL(this, "Bad type Expr::list::parent"); if (isExpr(list->parent)) INT_FATAL(this, "Expr::list::parent is an Expr unexpectedly"); } }
elem *Module::toEmodulename() { elem *efilename; // Get filename if (needModuleInfo()) { Symbol *si; /* Class ModuleInfo is defined in std.moduleinfo. * The first member is the name of it, char name[], * which will be at offset 8. */ si = toSymbol(); #if 1 // Use this instead so -fPIC will work efilename = el_ptr(si); efilename = el_bin(OPadd, TYnptr, efilename, el_long(TYuint, 8)); efilename = el_una(OPind, TYdarray, efilename); #else efilename = el_var(si); efilename->Ety = TYdarray; efilename->EV.sp.Voffset += 8; #endif } else // generate our own filename { efilename = toEfilename(); } return efilename; }
static void view_ast(BaseAST* ast, bool number = false, int mark = -1, int indent = 0) { if (!ast) return; if (Expr* expr = toExpr(ast)) { printf("\n"); for (int i = 0; i < indent; i++) printf(" "); printf("("); if (ast->id == mark) printf("***"); if (number) printf("%d ", ast->id); printf("%s", expr->astTagAsString()); if (isBlockStmt(expr)) if (FnSymbol* fn = toFnSymbol(expr->parentSymbol)) if (expr == fn->where) printf(" where"); if (GotoStmt *gs= toGotoStmt(ast)) { printf( " "); view_ast(gs->label, number, mark, indent+1); } if (CallExpr* call = toCallExpr(expr)) if (call->primitive) printf(" %s", call->primitive->name); if (NamedExpr* named = toNamedExpr(expr)) printf(" \"%s\"", named->name); if (toDefExpr(expr)) printf(" "); int64_t i; const char *str; if (get_int(expr, &i)) { printf(" %" PRId64, i); } else if (get_string(expr, &str)) { printf(" \"%s\"", str); } if (SymExpr* sym = toSymExpr(expr)) { printf(" "); view_sym(sym->var, number, mark); } else if (UnresolvedSymExpr* sym = toUnresolvedSymExpr(expr)) { printf(" '%s'", sym->unresolved); } } if (Symbol* sym = toSymbol(ast)) { view_sym(sym, number, mark); } AST_CHILDREN_CALL(ast, view_ast, number, mark, indent+2); if (toExpr(ast)) printf(")"); }
Symbol *FuncDeclaration::toThunkSymbol(int offset) { toSymbol(this); Symbol *sthunk = symbol_generate(SCstatic, csym->Stype); sthunk->Sflags |= SFLimplem; cod3_thunk(sthunk, csym, 0, TYnptr, -offset, -1, 0); return sthunk; }
Symbol *toSymbol(Type *t) { if (t->ty == Tclass) { return toSymbol(((TypeClass *)t)->sym); } assert(0); return NULL; }
Symbol *toThunkSymbol(FuncDeclaration *fd, int offset) { toSymbol(fd); Symbol *sthunk = symbol_generate(SCstatic, fd->csym->Stype); sthunk->Sflags |= SFLimplem; cod3_thunk(sthunk, fd->csym, 0, TYnptr, -offset, -1, 0); return sthunk; }
void visit(TypeInfoAssociativeArrayDeclaration *d) { //printf("TypeInfoAssociativeArrayDeclaration::toDt()\n"); verifyStructSize(Type::typeinfoassociativearray, 4 * Target::ptrsize); dtxoff(pdt, Type::typeinfoassociativearray->toVtblSymbol(), 0); // vtbl for TypeInfo_AssociativeArray dtsize_t(pdt, 0); // monitor assert(d->tinfo->ty == Taarray); TypeAArray *tc = (TypeAArray *)d->tinfo; tc->next->genTypeInfo(NULL); dtxoff(pdt, toSymbol(tc->next->vtinfo), 0); // TypeInfo for array of type tc->index->genTypeInfo(NULL); dtxoff(pdt, toSymbol(tc->index->vtinfo), 0); // TypeInfo for array of type }
Symbol *Dsymbol::toImport() { if (!isym) { if (!csym) csym = toSymbol(); isym = toImport(csym); } return isym; }
void list_view_noline(BaseAST* ast) { if (ast==NULL) { printf("<NULL>"); } else { if (toSymbol(ast)) printf("%-7d ", ast->id); list_ast(ast); } fflush(stdout); }
Symbol *toImport(Dsymbol *ds) { if (!ds->isym) { if (!ds->csym) ds->csym = toSymbol(ds); ds->isym = toImport(ds->csym); } return ds->isym; }
void visit(SwitchErrorStatement *s) { Blockx *blx = irs->blx; //printf("SwitchErrorStatement::toIR()\n"); elem *efilename = el_ptr(toSymbol(blx->module)); elem *elinnum = el_long(TYint, s->loc.linnum); elem *e = el_bin(OPcall, TYvoid, el_var(getRtlsym(RTLSYM_DSWITCHERR)), el_param(elinnum, efilename)); block_appendexp(blx->curblock, e); }
symbol *callFuncsAndGates(Module *m, symbols *sctors, StaticDtorDeclarations *ectorgates, const char *id) { symbol *sctor = NULL; if ((sctors && sctors->dim) || (ectorgates && ectorgates->dim)) { static type *t; if (!t) { /* t will be the type of the functions generated: * extern (C) void func(); */ t = type_function(TYnfunc, NULL, 0, false, tsvoid); t->Tmangle = mTYman_c; } localgot = NULL; sctor = toSymbolX(m, id, SCglobal, t, "FZv"); cstate.CSpsymtab = &sctor->Sfunc->Flocsym; elem *ector = NULL; if (ectorgates) { for (size_t i = 0; i < ectorgates->dim; i++) { StaticDtorDeclaration *f = (*ectorgates)[i]; Symbol *s = toSymbol(f->vgate); elem *e = el_var(s); e = el_bin(OPaddass, TYint, e, el_long(TYint, 1)); ector = el_combine(ector, e); } } if (sctors) { for (size_t i = 0; i < sctors->dim; i++) { symbol *s = (*sctors)[i]; elem *e = el_una(OPucall, TYvoid, el_var(s)); ector = el_combine(ector, e); } } block *b = block_calloc(); b->BC = BCret; b->Belem = ector; sctor->Sfunc->Fstartline.Sfilename = m->arg; sctor->Sfunc->Fstartblock = b; writefunc(sctor); } return sctor; }
void visit(TypeInfoWildDeclaration *d) { //printf("TypeInfoWildDeclaration::toDt() %s\n", toChars()); verifyStructSize(Type::typeinfowild, 3 * Target::ptrsize); dtxoff(pdt, Type::typeinfowild->toVtblSymbol(), 0); // vtbl for TypeInfo_Wild dtsize_t(pdt, 0); // monitor Type *tm = d->tinfo->mutableOf(); tm = tm->merge(); tm->genTypeInfo(NULL); dtxoff(pdt, toSymbol(tm->vtinfo), 0); }
void localizeGlobals() { if (fNoGlobalConstOpt) return; forv_Vec(FnSymbol, fn, gFnSymbols) { Map<Symbol*,VarSymbol*> globals; std::vector<BaseAST*> asts; collect_asts(fn->body, asts); for_vector(BaseAST, ast, asts) { if (SymExpr* se = toSymExpr(ast)) { Symbol* var = se->symbol(); ModuleSymbol* parentmod = toModuleSymbol(var->defPoint->parentSymbol); CallExpr* parentExpr = toCallExpr(se->parentExpr); bool inAddrOf = parentExpr && parentExpr->isPrimitive(PRIM_ADDR_OF); bool lhsOfMove = parentExpr && isMoveOrAssign(parentExpr) && (parentExpr->get(1) == se); // Is var a global constant? // Don't replace the var name in its init function since that's // where we're setting the value. Similarly, dont replace them // inside initStringLiterals // If the parentSymbol is the rootModule, the var is 'void,' // 'false,' '0,' ... // Also don't replace it when it's in an addr of primitive. if (parentmod && fn != parentmod->initFn && fn != initStringLiterals && !inAddrOf && !lhsOfMove && var->hasFlag(FLAG_CONST) && var->defPoint->parentSymbol != rootModule) { VarSymbol* local_global = globals.get(var); SET_LINENO(se); // Set the se line number for output if (!local_global) { const char * newname = astr("local_", var->cname); local_global = newTemp(newname, var->type); fn->insertAtHead(new CallExpr(PRIM_MOVE, local_global, var)); fn->insertAtHead(new DefExpr(local_global)); // Copy string immediates to localized strings so that // we can show the string value in comments next to uses. if (!llvmCodegen) if (VarSymbol* localVarSym = toVarSymbol(var)) if (Immediate* immediate = localVarSym->immediate) if (immediate->const_kind == CONST_KIND_STRING) local_global->immediate = new Immediate(immediate->v_string, immediate->string_kind); globals.put(var, local_global); } se->replace(new SymExpr(toSymbol(local_global))); } } } }
// // Print routines for debugging and development // void printNode(BaseAST* ast) { Symbol* sym = toSymbol(ast); WideInfo* wi = wideInfoMap.get(sym); printf("%s[%d]\n", sym->cname, sym->id); printf("%s\n", (wi->mustBeWide) ? "WIDE" : "NARROW"); printf("IN: "); forv_Vec(Symbol, inSym, wi->inVec) printf("%d ", inSym->id); printf("\n"); printf("OUT: "); forv_Vec(Symbol, outSym, wi->outVec) printf("%d ", outSym->id); printf("\n"); }
void visit(TypeInfoPointerDeclaration *d) { //printf("TypeInfoPointerDeclaration::toDt()\n"); verifyStructSize(Type::typeinfopointer, 3 * Target::ptrsize); dtxoff(pdt, Type::typeinfopointer->toVtblSymbol(), 0); // vtbl for TypeInfo_Pointer dtsize_t(pdt, 0); // monitor assert(d->tinfo->ty == Tpointer); TypePointer *tc = (TypePointer *)d->tinfo; tc->next->genTypeInfo(NULL); dtxoff(pdt, toSymbol(tc->next->vtinfo), 0); // TypeInfo for type being pointed to }
void visit(TypeInfoVectorDeclaration *d) { //printf("TypeInfoVectorDeclaration::toDt()\n"); verifyStructSize(Type::typeinfovector, 3 * Target::ptrsize); dtxoff(pdt, Type::typeinfovector->toVtblSymbol(), 0); // vtbl for TypeInfo_Vector dtsize_t(pdt, 0); // monitor assert(d->tinfo->ty == Tvector); TypeVector *tc = (TypeVector *)d->tinfo; tc->basetype->genTypeInfo(NULL); dtxoff(pdt, toSymbol(tc->basetype->vtinfo), 0); // TypeInfo for equivalent static array }
void viewFlags(BaseAST* ast) { if (!viewFlagsShort && !viewFlagsName && !viewFlagsComment) viewFlagsName = true; if (Symbol* sym = toSymbol(ast)) { for (int flagNum = FLAG_FIRST; flagNum <= FLAG_LAST; flagNum++) { if (sym->flags[flagNum]) { if (viewFlagsName) printf("%s ", flagNames[flagNum]); if (viewFlagsPragma) printf("%s", flagPragma[flagNum] ? "ypr " : "npr "); if (viewFlagsShort) printf("\"%s\" ", flagShortNames[flagNum]); if (viewFlagsComment) printf("// %s", *flagComments[flagNum] ? flagComments[flagNum] : "ncm"); printf("\n"); } } if (viewFlagsExtras) { if (VarSymbol* vs = toVarSymbol(sym)) { if (vs->immediate) { printf("immediate "); fprint_imm(stdout, *toVarSymbol(sym)->immediate, true); printf("\n"); } } else if (ArgSymbol* as = toArgSymbol(sym)) { printf("%s arg\n", as->intentDescrString()); } else if (toTypeSymbol(sym)) { printf("a TypeSymbol\n"); } else if (FnSymbol* fs = toFnSymbol(sym)) { printf("fn %s(%d args) %s\n", fs->_this ? intentDescrString(fs->thisTag) : "", fs->numFormals(), retTagDescrString(fs->retTag)); } else if (toEnumSymbol(sym)) { printf("an EnumSymbol\n"); } else if (ModuleSymbol* ms = toModuleSymbol(sym)) { printf("module %s\n", modTagDescrString(ms->modTag)); } else if (toLabelSymbol(sym)) { printf("a LabelSymbol\n"); } else { printf("unknown symbol kind\n"); } } } else { printf("[%d]: not a Symbol, has no flags\n", ast->id); } }
UseStmt::UseStmt(BaseAST* source) : Stmt(E_UseStmt) { src = NULL; except = false; if (Symbol* b = toSymbol(source)) { src = new SymExpr(b); } else if (Expr* b = toExpr(source)) { src = b; } else { INT_FATAL(this, "Bad mod in UseStmt constructor"); } gUseStmts.add(this); }
void visit(PragmaStatement *s) { //printf("PragmaStatement::toIR()\n"); if (s->ident == Id::startaddress) { assert(s->args && s->args->dim == 1); Expression *e = (*s->args)[0]; Dsymbol *sa = getDsymbol(e); FuncDeclaration *f = sa->isFuncDeclaration(); assert(f); Symbol *sym = toSymbol(f); while (irs->prev) irs = irs->prev; irs->startaddress = sym; } }
void visit(TypeInfoStaticArrayDeclaration *d) { //printf("TypeInfoStaticArrayDeclaration::toDt()\n"); verifyStructSize(Type::typeinfostaticarray, 4 * Target::ptrsize); dtxoff(pdt, Type::typeinfostaticarray->toVtblSymbol(), 0); // vtbl for TypeInfo_StaticArray dtsize_t(pdt, 0); // monitor assert(d->tinfo->ty == Tsarray); TypeSArray *tc = (TypeSArray *)d->tinfo; tc->next->genTypeInfo(NULL); dtxoff(pdt, toSymbol(tc->next->vtinfo), 0); // TypeInfo for array of type dtsize_t(pdt, tc->dim->toInteger()); // length }
Symbol *toVtblSymbol(ClassDeclaration *cd) { if (!cd->vtblsym) { if (!cd->csym) toSymbol(cd); TYPE *t = type_allocn(TYnptr | mTYconst, tsvoid); t->Tmangle = mTYman_d; Symbol *s = toSymbolX(cd, "__vtbl", SCextern, t, "Z"); s->Sflags |= SFLnodebug; s->Sfl = FLextern; cd->vtblsym = s; slist_add(s); } return cd->vtblsym; }
static Symbol* symflagOK(const char* msg, BaseAST* ast, int flag) { Symbol* sym = toSymbol(ast); if (!sym) { printf("%s: [%d] is a %s (does not support Flags)\n", msg, ast->id, ast->astTagAsString()); return NULL; } else if (flag <= 0) { printf("%s: flag is non-positive: %d\n", msg, flag); return NULL; } else if (flag >= NUM_FLAGS) { printf("%s: flag is too big (NUM_FLAGS is %d): %d\n", msg, NUM_FLAGS, flag); return NULL; } else { printf("%s(%s=%d)\n", msg, flagNames[flag], flag); return sym; } }
void TypeInfoDeclaration::toObjFile(int multiobj) { Symbol *s; unsigned sz; Dsymbol *parent; //printf("TypeInfoDeclaration::toObjFile(%p '%s') protection %d\n", this, toChars(), protection); if (multiobj) { obj_append(this); return; } s = toSymbol(); sz = type->size(); parent = this->toParent(); s->Sclass = SCcomdat; s->Sfl = FLdata; toDt(&s->Sdt); dt_optimize(s->Sdt); // See if we can convert a comdat to a comdef, // which saves on exe file space. if (s->Sclass == SCcomdat && s->Sdt->dt == DT_azeros && s->Sdt->DTnext == NULL) { s->Sclass = SCglobal; s->Sdt->dt = DT_common; } #if ELFOBJ || MACHOBJ // Burton if (s->Sdt && s->Sdt->dt == DT_azeros && s->Sdt->DTnext == NULL) s->Sseg = UDATA; else s->Sseg = DATA; #endif outdata(s); if (isExport()) obj_export(s,0); }
void visit(TypeInfoEnumDeclaration *d) { //printf("TypeInfoEnumDeclaration::toDt()\n"); verifyStructSize(Type::typeinfoenum, 7 * Target::ptrsize); dtxoff(pdt, Type::typeinfoenum->toVtblSymbol(), 0); // vtbl for TypeInfo_Enum dtsize_t(pdt, 0); // monitor assert(d->tinfo->ty == Tenum); TypeEnum *tc = (TypeEnum *)d->tinfo; EnumDeclaration *sd = tc->sym; /* Put out: * TypeInfo base; * char[] name; * void[] m_init; */ if (sd->memtype) { sd->memtype->genTypeInfo(NULL); dtxoff(pdt, toSymbol(sd->memtype->vtinfo), 0); // TypeInfo for enum members } else dtsize_t(pdt, 0); const char *name = sd->toPrettyChars(); size_t namelen = strlen(name); dtsize_t(pdt, namelen); dtabytes(pdt, 0, namelen + 1, name); // void[] init; if (!sd->members || d->tinfo->isZeroInit()) { // 0 initializer, or the same as the base type dtsize_t(pdt, 0); // init.length dtsize_t(pdt, 0); // init.ptr } else { dtsize_t(pdt, sd->type->size()); // init.length dtxoff(pdt, sd->toInitializer(), 0); // init.ptr } }