I wasn't very excited about moving it either, but I didn't see any other way to make it work. It's been a little while so I may have mixed up the details a little, but I think it was that StaticInst defines its execute/initiateAcc/completeAcc functions to return a Fault object, so static_inst.hh needs to include whatever defines the Fault type. Fault is really just reference counted pointer, but gcc was very uncooperative when I tried to just declare the type in static_inst.hh, but more on that below. In sim/faults.hh the invoke method now would take a StaticInstPtr parameter, so it needed to include the definition of that. gcc got cranky about just declaring that type too for I presume the same reasons. So if StaticInstPtr is defined in cpu/static_inst.hh and Fault is defined in sim/faults.hh, those two files include each other and things break. I initially tried moving StaticInstPtr out of cpu/static_inst.hh, but that didn't really work. Fortunately, faults don't have quite the same usage pattern so it worked to move the Fault type.

I did a little reading and a little pondering and I think one reasons gcc gets upset about prototyping reference counted pointers is the dereference operator. Everything else deals with a T*, but that dereferences and returns a const reference. The const reference should still be ok, but I guess there may be a subtle issue there since it makes a round trip through the underlying type. Also there are the calls to incref and decref, but those should be available from the base RefCounted class and shouldn't be ambiguous. Although now that I look at it, the template won't know what the base class of T is, so it won't know how to handle those calls. Would it fix things if we explicitly cast down to a RefCounted pointer before the calls to make things more explicit? Or a Base template parameter that was defaulted to RefCounted in case somebody (for whatever reason) wanted to use something else? One other issue I ran into is that gcc won't let you predeclare something that ends up being a typedef with the class keyword. Since many or maybe even all reference counted pointer types are actually typedefs to hide the template argument and I don't know how to declare a typedef without having the underlying type handy, things got tricky there too.

In any case, I wasn't comfortable fiddling with that too much since I could accidentally introduce very subtle bugs and I'd found an imperfect but working solution. If you know of a way to make, say, StaticInstPtr as easy to declare as class StaticInst, that would actually improve things anywhere we use reference counted pointers which would be great.

Perhaps you can do the forward declaration that I proposed in static_inst.hh now?  I'm still not quite clear on where the loop is, do you have an old diff with the problem that I can read?