Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 9facf3b0994f0b1e51acecc9de03cae8628dc5fa)
+++ src/InitTweak/FixInit.cc	(revision 8f60f0b80dde503acf9a6e096722d033fe5571f7)
@@ -346,5 +346,5 @@
 
 			if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
-				if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
+				if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
 					// optimization: don't need to copy construct in order to call intrinsic functions
 					return appExpr;
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 9facf3b0994f0b1e51acecc9de03cae8628dc5fa)
+++ src/InitTweak/InitTweak.cc	(revision 8f60f0b80dde503acf9a6e096722d033fe5571f7)
@@ -304,4 +304,15 @@
 
 	namespace {
+		DeclarationWithType * getCalledFunction( Expression * expr );
+
+		template<typename CallExpr>
+		DeclarationWithType * handleDerefCalledFunction( CallExpr * expr ) {
+			// (*f)(x) => should get "f"
+			std::string name = getFunctionName( expr );
+			assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+			assertf( ! expr->get_args().empty(), "Can't get called function from dereference with no arguments" );
+			return getCalledFunction( expr->get_args().front() );
+		}
+
 		DeclarationWithType * getCalledFunction( Expression * expr ) {
 			assert( expr );
@@ -312,4 +323,8 @@
 			} else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
 				return getCalledFunction( castExpr->get_arg() );
+			} else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
+				return handleDerefCalledFunction( untypedExpr );
+			} else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
+				return handleDerefCalledFunction( appExpr );
 			}
 			return nullptr;
@@ -377,4 +392,15 @@
 
 	namespace {
+		std::string funcName( Expression * func );
+
+		template<typename CallExpr>
+		std::string handleDerefName( CallExpr * expr ) {
+			// (*f)(x) => should get name "f"
+			std::string name = getFunctionName( expr );
+			assertf( name == "*?", "Unexpected untyped expression: %s", name.c_str() );
+			assertf( ! expr->get_args().empty(), "Can't get function name from dereference with no arguments" );
+			return funcName( expr->get_args().front() );
+		}
+
 		std::string funcName( Expression * func ) {
 			if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( func ) ) {
@@ -388,4 +414,8 @@
 			} else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
 				return funcName( memberExpr->get_member() );
+			} else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( func ) ) {
+				return handleDerefName( untypedExpr );
+			} else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( func ) ) {
+				return handleDerefName( appExpr );
 			} else {
 				assertf( false, "Unexpected expression type being called as a function in call expression" );
@@ -395,4 +425,7 @@
 
 	std::string getFunctionName( Expression * expr ) {
+		// there's some unforunate overlap here with getCalledFunction. Ideally this would be able to use getCalledFunction and
+		// return the name of the DeclarationWithType, but this needs to work for NameExpr and UntypedMemberExpr, where getCalledFunction
+		// can't possibly do anything reasonable.
 		if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ) ) {
 			return funcName( appExpr->get_function() );