public static EmitDebugInfo ( ILGen ilg, IPersistentMap spanMap ) : void | ||
ilg | ILGen | |
spanMap | IPersistentMap | |
return | void |
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { GenContext.EmitDebugInfo(ilg, _spanMap); if (_method != null) { EmitForMethod(objx, ilg); } else { throw new InvalidOperationException("Unboxed emit of unknown member."); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
private ConstructorBuilder EmitConstructor(TypeBuilder fnTB, Type baseType) { ConstructorBuilder cb = fnTB.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, CtorTypes()); CljILGen gen = new CljILGen(cb.GetILGenerator()); GenContext.EmitDebugInfo(gen, SpanMap); //Call base constructor ConstructorInfo baseCtorInfo = baseType.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, null, Type.EmptyTypes, null); if (baseCtorInfo == null) { throw new InvalidOperationException("Unable to find default constructor for " + baseType.FullName); } gen.EmitLoadArg(0); gen.Emit(OpCodes.Call, baseCtorInfo); // Store Meta if (SupportsMeta) { gen.EmitLoadArg(0); gen.EmitLoadArg(1); gen.Emit(OpCodes.Castclass, typeof(IPersistentMap)); gen.EmitFieldSet(_metaField); } // store closed-overs in their fields int a = 0; int offset = !SupportsMeta ? 1 : 2; for (ISeq s = RT.keys(Closes); s != null; s = s.next(), a++) { //LocalBinding lb = (LocalBinding)s.first(); FieldBuilder fb = _closedOverFields[a]; gen.EmitLoadArg(0); // gen.Emit(OpCodes.Ldarg_0); gen.EmitLoadArg(a + offset); // gen.Emit(OpCodes.Ldarg, a + 1); gen.Emit(OpCodes.Stfld, fb); } gen.Emit(OpCodes.Ret); return(cb); }
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { GenContext.EmitDebugInfo(ilg, _spanMap); if (_isProtocol) { EmitProto(rhc, objx, ilg); } else { _fexpr.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Castclass, typeof(IFn)); EmitArgsAndCall(0, rhc, objx, ilg); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public override void EmitAssign(RHC rhc, ObjExpr objx, CljILGen ilg, Expr val) { if (_tinfo.IsInitOnly) { throw new InvalidOperationException(String.Format("Attempt to set readonly static field {0} in class {1}", _tinfo.Name, _tinfo.DeclaringType)); } GenContext.EmitDebugInfo(ilg, _spanMap); val.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Dup); HostExpr.EmitUnboxArg(objx, ilg, FieldType); ilg.MaybeEmitVolatileOp(_tinfo); ilg.EmitFieldSet(_tinfo); if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
private void EmitStaticConstructorBody(CljILGen ilg) { GenContext.EmitDebugInfo(ilg, SpanMap); if (Constants.count() > 0) { EmitConstantFieldInits(ilg); } if (KeywordCallsites.count() > 0) { EmitKeywordCallsiteInits(ilg); } if (IsDefType && RT.booleanCast(RT.get(Opts, Compiler.LoadNsKeyword))) { EmitLoadNsInitForDeftype(ilg); } ilg.Emit(OpCodes.Ret); }
public virtual void Emit(ObjExpr fn, TypeBuilder tb) { MethodBuilder mb = tb.DefineMethod(MethodName, MethodAttributes.Public, ReturnType, ArgTypes); CljILGen ilg = new CljILGen(mb.GetILGenerator()); Label loopLabel = ilg.DefineLabel(); GenContext.EmitDebugInfo(ilg, SpanMap); try { Var.pushThreadBindings(RT.map(Compiler.LoopLabelVar, loopLabel, Compiler.MethodVar, this)); ilg.MarkLabel(loopLabel); Body.Emit(RHC.Return, fn, ilg); ilg.Emit(OpCodes.Ret); } finally { Var.popThreadBindings(); } }
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { Type targetType = _targetType; //Type stubType = Compiler.CompileStubOrigClassVar.isBound ? (Type)Compiler.CompileStubOrigClassVar.deref() : null; //if (_targetType == stubType) // targetType = objx.BaseType; GenContext.EmitDebugInfo(ilg, _spanMap); if (targetType != null && _tinfo != null) { _target.Emit(RHC.Expression, objx, ilg); MethodExpr.EmitPrepForCall(ilg, typeof(object), FieldDeclaringType); EmitGet(ilg); } else { throw new InvalidOperationException("Unboxed emit of unknown member."); } }
public override void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { GenContext.EmitDebugInfo(ilg, _spanMap); Type retType; if (_method != null) { EmitForMethod(objx, ilg); retType = _method.ReturnType; } else { EmitComplexCall(objx, ilg); retType = typeof(object); } HostExpr.EmitBoxReturn(objx, ilg, retType); if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public override void EmitAssign(RHC rhc, ObjExpr objx, CljILGen ilg, Expr val) { GenContext.EmitDebugInfo(ilg, _spanMap); if (_targetType != null && _tinfo != null) { _target.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Castclass, _targetType); val.Emit(RHC.Expression, objx, ilg); LocalBuilder tmp = ilg.DeclareLocal(typeof(object)); GenContext.SetLocalName(tmp, "valTemp"); ilg.Emit(OpCodes.Dup); ilg.Emit(OpCodes.Stloc, tmp); if (FieldType.IsValueType) { HostExpr.EmitUnboxArg(objx, ilg, FieldType); } else { ilg.Emit(OpCodes.Castclass, FieldType); } EmitSet(ilg); ilg.Emit(OpCodes.Ldloc, tmp); } else { _target.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Ldstr, _memberName); val.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Call, Compiler.Method_Reflector_SetInstanceFieldOrProperty); } if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public override void Emit(ObjExpr fn, TypeBuilder tb) { MethodBuilder mb = tb.DefineMethod(GetMethodName(), MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual, GetReturnType(), GetArgTypes()); SetCustomAttributes(mb); //Console.Write("Compiling method {0} ", GetMethodName()); //foreach (Type t in GetArgTypes()) // Console.Write("{0}, ", t.Name); //Console.WriteLine("returning {0}", GetReturnType().Name); CljILGen ilg = new CljILGen(mb.GetILGenerator()); Label loopLabel = ilg.DefineLabel(); GenContext.EmitDebugInfo(ilg, SpanMap); try { Var.pushThreadBindings(RT.map(Compiler.LoopLabelVar, loopLabel, Compiler.MethodVar, this)); ilg.MarkLabel(loopLabel); EmitBody(Objx, ilg, _retType, _body); if (_body.HasNormalExit()) { ilg.Emit(OpCodes.Ret); } } finally { Var.popThreadBindings(); } if (IsExplicit) { tb.DefineMethodOverride(mb, _explicitMethodInfo); } }
public void DoEmit(RHC rhc, ObjExpr objx, CljILGen ilg, bool emitUnboxed) { GenContext.EmitDebugInfo(ilg, _sourceSpan); Label defaultLabel = ilg.DefineLabel(); Label endLabel = ilg.DefineLabel(); SortedDictionary <int, Label> labels = new SortedDictionary <int, Label>(); foreach (int i in _tests.Keys) { labels[i] = ilg.DefineLabel(); } Type primExprType = Compiler.MaybePrimitiveType(_expr); if (_testType == _intKey) { EmitExprForInts(objx, ilg, primExprType, defaultLabel); } else { EmitExprForHashes(objx, ilg); } if (_switchType == _sparseKey) { Label[] la = labels.Values.ToArray <Label>(); ilg.Emit(OpCodes.Switch, la); ilg.Emit(OpCodes.Br, defaultLabel); } else { Label[] la = new Label[(_high - _low) + 1]; for (int i = _low; i <= _high; i++) { la[i - _low] = labels.ContainsKey(i) ? labels[i] : defaultLabel; } ilg.EmitInt(_low); ilg.Emit(OpCodes.Sub); ilg.Emit(OpCodes.Switch, la); ilg.Emit(OpCodes.Br, defaultLabel); } foreach (int i in labels.Keys) { ilg.MarkLabel(labels[i]); if (_testType == _intKey) { EmitThenForInts(objx, ilg, primExprType, _tests[i], _thens[i], defaultLabel, emitUnboxed); } else if ((bool)RT.contains(_skipCheck, i)) { EmitExpr(objx, ilg, _thens[i], emitUnboxed); } else { EmitThenForHashes(objx, ilg, _tests[i], _thens[i], defaultLabel, emitUnboxed); } if (_thens[i].HasNormalExit()) { ilg.Emit(OpCodes.Br, endLabel); } } ilg.MarkLabel(defaultLabel); EmitExpr(objx, ilg, _defaultExpr, emitUnboxed); ilg.MarkLabel(endLabel); if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
private void DoEmitPrim(ObjExpr fn, TypeBuilder tb) { MethodAttributes attribs = MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual; string methodName = "invokePrim"; Type returnType; if (_retType == typeof(double) || _retType == typeof(long)) { returnType = ReturnType; } else { returnType = typeof(object); } MethodBuilder baseMB = tb.DefineMethod(methodName, attribs, returnType, _argTypes); SetCustomAttributes(baseMB); CljILGen baseIlg = new CljILGen(baseMB.GetILGenerator()); try { Label loopLabel = baseIlg.DefineLabel(); Var.pushThreadBindings(RT.map(Compiler.LoopLabelVar, loopLabel, Compiler.MethodVar, this)); GenContext.EmitDebugInfo(baseIlg, SpanMap); baseIlg.MarkLabel(loopLabel); EmitBody(Objx, baseIlg, _retType, Body); if (Body.HasNormalExit()) { baseIlg.Emit(OpCodes.Ret); } } finally { Var.popThreadBindings(); } // Generate the regular invoke, calling the prim method MethodBuilder regularMB = tb.DefineMethod(MethodName, MethodAttributes.ReuseSlot | MethodAttributes.Public | MethodAttributes.Virtual, typeof(Object), ArgTypes); SetCustomAttributes(regularMB); CljILGen regIlg = new CljILGen(regularMB.GetILGenerator()); regIlg.Emit(OpCodes.Ldarg_0); for (int i = 0; i < _argTypes.Length; i++) { regIlg.EmitLoadArg(i + 1); HostExpr.EmitUnboxArg(fn, regIlg, _argTypes[i]); } regIlg.Emit(OpCodes.Call, baseMB); if (ReturnType.IsValueType) { regIlg.Emit(OpCodes.Box, ReturnType); } regIlg.Emit(OpCodes.Ret); }
public void Emit(RHC rhc, ObjExpr objx, CljILGen ilg) { Label endLabel = ilg.DefineLabel(); Label faultLabel = ilg.DefineLabel(); GenContext.EmitDebugInfo(ilg, _spanMap); LocalBuilder thunkLoc = ilg.DeclareLocal(typeof(ILookupThunk)); LocalBuilder targetLoc = ilg.DeclareLocal(typeof(Object)); LocalBuilder resultLoc = ilg.DeclareLocal(typeof(Object)); GenContext.SetLocalName(thunkLoc, "thunk"); GenContext.SetLocalName(targetLoc, "target"); GenContext.SetLocalName(resultLoc, "result"); // TODO: Debug info // pseudo-code: // ILookupThunk thunk = objclass.ThunkField(i) // object target = ...code... // object val = thunk.get(target) // if ( val != thunk ) // return val // else // KeywordLookupSite site = objclass.SiteField(i) // thunk = site.fault(target) // objclass.ThunkField(i) = thunk // val = thunk.get(target) // return val ilg.EmitFieldGet(objx.ThunkField(_siteIndex)); // thunk ilg.Emit(OpCodes.Stloc, thunkLoc); // (thunkLoc <= thunk) _target.Emit(RHC.Expression, objx, ilg); // target ilg.Emit(OpCodes.Stloc, targetLoc); // (targetLoc <= target) ilg.Emit(OpCodes.Ldloc, thunkLoc); ilg.Emit(OpCodes.Ldloc, targetLoc); ilg.EmitCall(Compiler.Method_ILookupThunk_get); // result ilg.Emit(OpCodes.Stloc, resultLoc); // (resultLoc <= result) ilg.Emit(OpCodes.Ldloc, thunkLoc); ilg.Emit(OpCodes.Ldloc, resultLoc); ilg.Emit(OpCodes.Beq, faultLabel); ilg.Emit(OpCodes.Ldloc, resultLoc); // result ilg.Emit(OpCodes.Br, endLabel); ilg.MarkLabel(faultLabel); ilg.EmitFieldGet(objx.KeywordLookupSiteField(_siteIndex)); // site ilg.Emit(OpCodes.Ldloc, targetLoc); // site, target ilg.EmitCall(Compiler.Method_ILookupSite_fault); // new-thunk ilg.Emit(OpCodes.Dup); // new-thunk, new-thunk ilg.EmitFieldSet(objx.ThunkField(_siteIndex)); // new-thunk ilg.Emit(OpCodes.Ldloc, targetLoc); // new-thunk, target ilg.EmitCall(Compiler.Method_ILookupThunk_get); // result ilg.MarkLabel(endLabel); // result if (rhc == RHC.Statement) { ilg.Emit(OpCodes.Pop); } }
public override void EmitUnboxed(RHC rhc, ObjExpr objx, CljILGen ilg) { GenContext.EmitDebugInfo(ilg, _spanMap); ilg.EmitPropertyGet(_tinfo); }
void DoEmit(RHC rhc, ObjExpr objx, CljILGen ilg, bool emitUnboxed) { Label nullLabel = ilg.DefineLabel(); Label falseLabel = ilg.DefineLabel(); Label endLabel = ilg.DefineLabel(); Label trueLabel = ilg.DefineLabel(); GenContext.EmitDebugInfo(ilg, _sourceSpan); StaticMethodExpr sme = _testExpr as StaticMethodExpr; if (sme != null && sme.CanEmitIntrinsicPredicate()) { sme.EmitIntrinsicPredicate(RHC.Expression, objx, ilg, falseLabel); } else if (Compiler.MaybePrimitiveType(_testExpr) == typeof(bool)) { ((MaybePrimitiveExpr)_testExpr).EmitUnboxed(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Brfalse, falseLabel); } else { LocalBuilder tempLoc = ilg.DeclareLocal(typeof(Object)); GenContext.SetLocalName(tempLoc, "test"); _testExpr.Emit(RHC.Expression, objx, ilg); ilg.Emit(OpCodes.Dup); ilg.Emit(OpCodes.Stloc, tempLoc); ilg.Emit(OpCodes.Brfalse, nullLabel); ilg.Emit(OpCodes.Ldloc, tempLoc); ilg.Emit(OpCodes.Isinst, typeof(bool)); ilg.Emit(OpCodes.Ldnull); ilg.Emit(OpCodes.Cgt_Un); ilg.Emit(OpCodes.Brfalse, trueLabel); ilg.Emit(OpCodes.Ldloc, tempLoc); ilg.Emit(OpCodes.Unbox_Any, typeof(bool)); ilg.Emit(OpCodes.Ldc_I4_0); ilg.Emit(OpCodes.Ceq); ilg.Emit(OpCodes.Brtrue, falseLabel); } ilg.MarkLabel(trueLabel); if (emitUnboxed) { ((MaybePrimitiveExpr)_thenExpr).EmitUnboxed(rhc, objx, ilg); } else { _thenExpr.Emit(rhc, objx, ilg); } if (_thenExpr.HasNormalExit()) { ilg.Emit(OpCodes.Br, endLabel); } ilg.MarkLabel(nullLabel); ilg.MarkLabel(falseLabel); if (emitUnboxed) { ((MaybePrimitiveExpr)_elseExpr).EmitUnboxed(rhc, objx, ilg); } else { _elseExpr.Emit(rhc, objx, ilg); } ilg.MarkLabel(endLabel); }