-BUGS
+EmitContext.ResolveTypeTree
+---------------------------
+
+ We should investigate its usage. The problem is that by default
+ this will be set when calling FindType, that triggers a more expensive
+ lookup.
+
+ I believe we should pass the current EmitContext (which has this turned off
+ by default) to ResolveType/REsolveTypeExpr and then have the routines that
+ need ResolveType to pass null as the emit context.
+
+Idea
----
-* Adding variables.
+ Keep a cache of name lookups at the DeclSpace level
- We do add variables in a number of places, and this is erroneous:
+Large project:
+--------------
- void a (int b)
- {
- int b;
- }
+ Drop FindMembers as our API and instead extract all the data
+ out of a type the first time into our own datastructures, and
+ use that to navigate and search the type instead of the
+ callback based FindMembers.
- Also:
+ Martin has some some of this work with his TypeHandle code
+ that we could use for this.
- void a (int b)
- {
- foreach (int b ...)
- ;
- }
+Notes on memory allocation
+--------------------------
+ A run of the AllocationProfile shows that the compiler allocates roughly
+ 30 megabytes of strings. From those, 20 megabytes come from
+ LookupType.
-* Implenment Array Initialization
+ See the notes on current_container problems below on memory usage.
-* FindMembers
+GetNamespaces
+-------------
- Move our utility FindMembers from TypeContainer to Decl, because interfaces
- are also scanned with it.
+ Obtaining the list of namespaces is an expensive process because
+ Reflection.Emit does not provide a quick way of pulling the data out,
+ and it is too slow to load it.
-* Visibility
+ Calling GetNamespaces on my machine (1Ghz):
- I am not reporting errors on visibility yet.
+ * Takes half a second with the standard assemblies (corlib + System);
+ Fetching the types from it takes 0.0028650 seconds.
-* Enumerations
+ * Loading the top 10 largest assemblies we ship with Mono makes MCS take
+ 8 seconds to startup the first time, subsequent invocations take 2 seconds.
- They currently can not be defined in terms of other enumerations
- or constants.
+ Fetching all the types (Assembly.GetTypes ()) for all the assemblies takes
+ 0.0069170 seconds.
-* Interfaces
+ So pulling all the types takes very little time, maybe we should look into our
+ Hashtable implementation to make it more optimal.
- For indexers, the output of ix2.cs is different from our
- compiler and theirs. They use a DefaultMemberAttribute, which
- I have yet to figure out:
+ This prohibits re-writting SimpleName to take advantage of
+ knowing the namespace names in advance. Knowing the namespaces in advance
+ would allow me to reduce the guesswork in which we are currently engaged
+ to find a type definition.
- .class interface private abstract auto ansi INTERFACE
- {
- .custom instance void [mscorlib]System.Reflection.DefaultMemberAttribute::.ctor(string)
- = ( 01 00 04 49 74 65 6D 00 00 ) // ...Item..
- ...
- }
+LookupTypeReflection:
+---------------------
-* Interface indexers
+ With something like `System.Object', LookupTypeReflection will be called
+ twice: once to find out that `System' is not a type and once
+ for System.Object.
- I have not figured out why the Microsoft version puts an
- `instance' attribute, and I am not generating this `instance' attribute.
+ This is required because System.Reflection requires that the type/nested types are
+ not separated by a dot but by a plus sign.
- Explanation: The reason for the `instance' attribute on
- indexers is that indexers only apply to instances
+ A nested class would be My+Class (My being the toplevel, Class the nested one).
-* In class.cs: Method.Define
+ It is interesting to look at the most called lookups when bootstrapping MCS:
- Need to use FindMembers to lookup the member for reporting
- whether a new is needed or not.
+ 647 LTR: ArrayList
+ 713 LTR: System.Globalization
+ 822 LTR: System.Object+Expression
+ 904 LTR: Mono.CSharp.ArrayList
+ 976 LTR: System.Runtime.CompilerServices
+ 999 LTR: Type
+ 1118 LTR: System.Runtime
+ 1208 LTR: Mono.CSharp.Type
+ 1373 LTR: Mono.Languages
+ 1599 LTR: System.Diagnostics
+ 2036 LTR: System.Text
+ 2302 LTR: System.Reflection.Emit
+ 2515 LTR: System.Collections
+ 4527 LTR: System.Reflection
+ 22273 LTR: Mono.CSharp
+ 24245 LTR: System
+ 27005 LTR: Mono
-* Foreach on structure returns does not work
+ Analysis:
+ The top 9 lookups are done for things which are not types.
- I am generating invalid code instead of calling ldarga for the
- structure, I am calling ldarg:
+ Mono.CSharp.Type happens to be a common lookup: the class Type
+ used heavily in the compiler in the default namespace.
- struct X {
- public IEnumerator GetEnumerator ();
- }
+ RED FLAG:
- X x;
+ Then `Type' is looked up alone a lot of the time, this happens
+ in parameter declarations and am not entirely sure that this is
+ correct (FindType will pass to LookupInterfaceOrClass a the current_type.FullName,
+ which for some reason is null!). This seems to be a problem with a lost
+ piece of context during FindType.
- foreach (object a in x){
- ...
- }
+ System.Object is also used a lot as a toplevel class, and we assume it will
+ have children, we should just shortcut this.
+
+ A cache:
+
+ Adding a cache and adding a catch for `System.Object' to flag that it wont be the
+ root of a hierarchy reduced the MCS bootstrap time from 10.22 seconds to 8.90 seconds.
- I need to get the address of that bad boy
+ This cache is currently enabled with SIMPLE_SPEEDUP in typemanager.cs. Memory consumption
+ went down from 74 megs to 65 megs with this change.
-* Handle destructors specially
+Ideas:
+------
- Turn ~X () { a () } into:
- void Finalize () { try { a (); } finally { base.Finalize (); } }
+ Instead of the hack that *knows* about System.Object not having any children classes,
+ we should just make it simple for a probe to know that there is no need for it.
-* Method Names
+The use of DottedName
+---------------------
- Method names could be; `IFACE.NAME' in the method declaration,
- stating that they implement a specific interface method.
+ We could probably use a different system to represent names, like this:
- We currently fail to parse it.
+ class Name {
+ string simplename;
+ Name parent;
+ }
+
+ So `System.ComponentModel' becomes:
+
+ x: (System, null)
+ y: (ComponentModel, x)
+
+ The problem is that we would still need to construct the name to pass to
+ GetType.
+
+current_container/current_namespace and the DeclSpace
+-----------------------------------------------------
-* Namespaces
+ We are storing fully qualified names in the DeclSpace instead of the node,
+ this is because `current_namespace' (Namepsace) is not a DeclSpace like
+ `current_container'.
- Apparently:
+ The reason for storing the full names today is this:
- namespace X {
+ namespace X {
+ class Y {
}
+ }
- namespace X {
+ namespace A {
+ class Y {
}
+ }
- Is failing to create a single namespace
+ The problem is that we only use the namespace stack to track the "prefix"
+ for typecontainers, but they are not typecontainers themselves, so we have
+ to use fully qualified names, because both A.X and A.Y would be entered
+ in the toplevel type container. If we use the short names, there would be
+ a name clash.
-* Arrays
+ To fix this problem, we have to make namespaces DeclSpaces.
- We need to make sure at *compile time* that the arguments in
- the expression list of an array creation are always positive.
+ The full size, contrasted with the size that could be stored is:
+ corlib:
+ Size of strings held: 368901
+ Size of strings short: 147863
-* Fix access to variables of type ref/out
+ System:
+ Size of strings held: 212677
+ Size of strings short: 97521
+
+ System.XML:
+ Size of strings held: 128055
+ Size of strings short: 35782
+
+ System.Data:
+ Size of strings held: 117896
+ Size of strings short: 36153
+
+ System.Web:
+ Size of strings held: 194527
+ Size of strings short: 58064
+
+ System.Windows.Forms:
+ Size of strings held: 220495
+ Size of strings short: 64923
-* Implement dead code elimination in statement.cs
+
+TODO:
- It is pretty simple to implement dead code elimination in
- if/do/while
+ 1. Create a "partial" emit context for each TypeContainer..
-* Indexer bugs:
+ 2. EmitContext should be partially constructed. No IL Generator.
- the following wont work:
+ interface_type review.
- x [0] = x [1] = N
+ parameter_array, line 952: `note: must be a single dimension array type'. Validate this
- if x has indexers, the value of x [N] set is set to void. This needs to be
- fixed.
+Dead Code Elimination bugs:
+---------------------------
-* Array declarations
+ I should also resolve all the children expressions in Switch, Fixed, Using.
- Multi-dim arrays are declared as [,] instead of [0..,0..]
+Major tasks:
+------------
+ Pinned and volatile require type modifiers that can not be encoded
+ with Reflection.Emit.
-PENDING TASKS
--------------
+ Properties and 17.6.3: Finish it.
- * Implement Using.
+ Implement base indexer access.
- * Implement Goto.
+readonly variables and ref/out
+
+BUGS
+----
- * Implement Switch.
+* Check for Final when overriding, if the parent is Final, then we cant
+ allow an override.
- * Unsafe code.
+* Interface indexers
-* Using Alias
+ I have not figured out why the Microsoft version puts an
+ `instance' attribute, and I am not generating this `instance' attribute.
- Need to reset the aliases for each compilation unit, so an
- alias defined in a file does not have any effect on another one:
+ Explanation: The reason for the `instance' attribute on
+ indexers is that indexers only apply to instances
- File.cs
- =======
- namespace A {
- using X = Blah;
+* Break/Continue statements
- class Z : X { <-- This X is `Blah'
- }
+ A finally block should reset the InLoop/LoopBegin/LoopEnd, as
+ they are logically outside the scope of the loop.
- File2.cs
- namespace {
- class Y : X { <-- This X Is not `Blah'
- }
- }
+* Break/continue part 2.
- I think we can implement Aliases by having an `Alias' context in all
- the toplevel TypeContainers of a compilation unit. The children typecontainers
- just chain to the parents to resolve the information.
+ They should transfer control to the finally block if inside a try/catch
+ block.
- The driver advances the Alias for each file compiled, so that each file
- has its own alias set.
+* Method Registration and error CS111
-* Handle volatile
+ The way we use the method registration to signal 111 is wrong.
+
+ Method registration should only be used to register methodbuilders,
+ we need an alternate method of checking for duplicates.
-* Support Re-Throw exceptions:
+*
+> // CSC sets beforefieldinit
+> class X {
+> // .cctor will be generated by compiler
+> public static readonly object O = new System.Object ();
+> public static void Main () {}
+> }
+>
- try {
- X ();
- } catch (SomeException e){
- LogIt ();
- throw;
- }
+PENDING TASKS
+-------------
-* Static flow analysis
+* Merge test 89 and test-34
- Required to warn about reachability of code and definite
- assignemt as well as missing returns on functions.
+* Revisit
+ Primary-expression, as it has now been split into
+ non-array-creation-expression and array-creation-expression.
+
+* Code cleanup
-OPTIMIZATIONS
--------------
+ The information when registering a method in InternalParameters
+ is duplicated, you can always get the types from the InternalParameters
-* Emitcontext
+* Emit modreq for volatiles
- Do we really need to instanciate this variable all the time?
+ Handle modreq from public apis.
- It could be static for all we care, and just use it for making
- sure that there are no recursive invocations on it.
+* Emit `pinned' for pinned local variables.
-* Static-ization
+ Both `modreq' and pinned will require special hacks in the compiler.
- Since AppDomain exists, maybe we can get rid of all the stuff
- that is part of the `compiler instance' and just use globals
- everywhere.
+* Make sure that we are pinning the right variable
+* Merge tree.cs, rootcontext.cs
-* Constructors
+OPTIMIZATIONS
+-------------
- Currently it calls the parent constructor before initializing fields.
- It should do it the other way around.
+* User Defined Conversions is doing way too many calls to do union sets that are not needed
-* Reducer and -Literal
+* Add test case for destructors
- Maybe we should never handle -Literal in Unary expressions and let
- the reducer take care of it always?
+* Places that use `Ldelema' are basically places where I will be
+ initializing a value type. I could apply an optimization to
+ disable the implicit local temporary from being created (by using
+ the method in New).
-* Use of EmitBranchable
+* Dropping TypeContainer as an argument to EmitContext
- Currently I use brfalse/brtrue in the code for statements, instead of
- using the EmitBranchable function that lives in Binary
+ My theory is that I can get rid of the TypeBuilder completely from
+ the EmitContext, and have typecasts where it is used (from
+ DeclSpace to where it matters).
-* Create an UnimplementedExpcetion
+ The only pending problem is that the code that implements Aliases
+ is on TypeContainer, and probably should go in DeclSpace.
- And use that instead of plain Exceptions to flag compiler errors.
+* Use of local temporary in UnaryMutator
-* ConvertImplicit
+ We should get rid of the Localtemporary there for some cases
- Currently ConvertImplicit will not catch things like:
+ This turns out to be very complex, at least for the post-version,
+ because this case:
- - IntLiteral in a float context to generate a -FloatLiteral.
- Instead it will perform an integer load followed by a conversion.
+ a = i++
+
+ To produce optimal code, it is necessary for UnaryMutator to know
+ that it is being assigned to a variable (the way the stack is laid
+ out using dup requires the store to happen inside UnaryMutator).
+
+* Emitcontext
+
+ Do we really need to instanciate this variable all the time?
+
+ It could be static for all we care, and just use it for making
+ sure that there are no recursive invocations on it.
* Tests
Write tests for the various reference conversions. We have
test for all the numeric conversions.
-* Remove the tree dumper
-
- And make all the stuff which is `public readonly' be private unless
- required.
-
* Optimizations
In Indexers and Properties, probably support an EmitWithDup
in the stack, so that later a Store can be emitted using that
this pointer (consider Property++ or Indexer++)
+* Optimizations: variable allocation.
+
+ When local variables of a type are required, we should request
+ the variable and later release it when we are done, so that
+ the same local variable slot can be reused later on.
+
+* Add a cache for the various GetArrayMethod operations.
+
+* TypeManager.FindMembers:
+
+ Instead of having hundreds of builder_to_blah hash table, have
+ a single one that maps a TypeBuilder `t' to a set of classes
+ that implement an interface that supports FindMembers.
+
+* MakeUnionSet Callers
+
+ If the types are the same, there is no need to compute the unionset,
+ we can just use the list from one of the types.
+
+* Factor the lookup code for class declarations an interfaces
+ (interface.cs:GetInterfaceByName)
RECOMMENDATIONS
---------------
Not sure that this grammar is correct, we might have to
resolve this during semantic analysis.
-
projects / mono.git / blobdiff