Optimize functions for templatized devfw calls.

Change-Id: Ieaa874ba86244108bb30dc67fde638d9a78900db
Reviewed-on: http://gfw160.austin.ibm.com:8080/gerrit/138
Tested-by: Jenkins Server
Reviewed-by: Nicholas E. Bofferding <bofferdn@us.ibm.com>
Reviewed-by: Thi N. Tran <thi@us.ibm.com>

1 files changed, 78 insertions, 101 deletions

diff --git a/src/usr/devicefw/driverif.C b/src/usr/devicefw/driverif.C
index f6109ffea..3e7a50113 100644
--- a/src/usr/devicefw/driverif.C
+++ b/src/usr/devicefw/driverif.C
@@ -8,119 +8,96 @@
 
 namespace DeviceFW
 {
-    template <> 
-    void deviceRegisterRoute<>(OperationType i_opType,
-                              AccessType i_accessType,
-                              TargetType_t i_targetType,
-                              deviceOp_t i_regRoute)
+    /** @brief Wrapper function to call singleton instance for registerRoute.
+     *
+     *  This is defined as an extern "C" function so that it can be aliased
+     *  by the template type-safe implementations of deviceRegisterRoute().
+     *  This causes the compiler to generate just a single copy of the code.
+     */
+    extern "C" 
+    void DeviceFW_deviceRegisterRoute(int64_t i_opType,
+                                      int64_t i_accessType,
+                                      int64_t i_targetType,
+                                      deviceOp_t i_regRoute)
     {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
+        Singleton<Associator>::instance().registerRoute(i_opType,
+                                                        i_accessType,
+                                                        i_targetType,
+                                                        i_regRoute);
     }
 
+    // deviceRegisterRoute:
+    //          OpType - OperationType or WILDCARD
+    //          TargType - TargetType or WILDCARD
+    //          AccType - AccessType, AccessType_DriverOnly (no WILDCARD).
+
     template <> 
     void deviceRegisterRoute<>(OperationType i_opType,
-                              AccessType_DriverOnly i_accessType,
-                              TargetType_t i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+                               AccessType i_accessType,
+                               TargetType_t i_targetType,
+                               deviceOp_t i_regRoute)
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
 
     template <> 
     void deviceRegisterRoute<>(OperationType i_opType,
-                              AccessType i_accessType,
-                              DriverSpecial i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+                               AccessType_DriverOnly i_accessType,
+                               TargetType_t i_targetType,
+                               deviceOp_t i_regRoute) 
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
 
     template <> 
     void deviceRegisterRoute<>(OperationType i_opType,
-                              AccessType_DriverOnly i_accessType,
-                              DriverSpecial i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+                               AccessType i_accessType,
+                               DriverSpecial i_targetType,
+                               deviceOp_t i_regRoute)
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
 
     template <> 
-    void deviceRegisterRoute<>(DriverSpecial i_opType,
-                              AccessType i_accessType,
-                              TargetType_t i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+    void deviceRegisterRoute<>(OperationType i_opType,
+                               AccessType_DriverOnly i_accessType,
+                               DriverSpecial i_targetType,
+                               deviceOp_t i_regRoute) 
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
 
     template <> 
     void deviceRegisterRoute<>(DriverSpecial i_opType,
-                              AccessType_DriverOnly i_accessType,
+                              AccessType i_accessType,
                               TargetType_t i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+                              deviceOp_t i_regRoute)
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
 
     template <> 
     void deviceRegisterRoute<>(DriverSpecial i_opType,
-                              AccessType i_accessType,
-                              DriverSpecial i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+                               AccessType_DriverOnly i_accessType,
+                               TargetType_t i_targetType,
+                               deviceOp_t i_regRoute)
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
 
     template <> 
     void deviceRegisterRoute<>(DriverSpecial i_opType,
-                              AccessType_DriverOnly i_accessType,
-                              DriverSpecial i_targetType,
-                              deviceOp_t i_regRoute) 
-    {
-        Singleton<Associator>::instance().registerRoute(
-                static_cast<int64_t>(i_opType),
-                static_cast<int64_t>(i_accessType),
-                static_cast<int64_t>(i_targetType),
-                i_regRoute);
-    }
+                               AccessType i_accessType,
+                               DriverSpecial i_targetType,
+                               deviceOp_t i_regRoute)
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));    
 
-    // deviceOp:
-    //          OpType - OperationType only.
-    //          TargType - TargetType only.
-    //          AccType - AccessType, AccessType_DriverOnly (no WILDCARD).
     template <> 
-    errlHndl_t deviceOp<>(OperationType i_opType,
-                          TargetHandle_t i_target,
-                          void* io_buffer, size_t& io_buflen,
-                          AccessType i_accessType, ...)
+    void deviceRegisterRoute<>(DriverSpecial i_opType,
+                               AccessType_DriverOnly i_accessType,
+                               DriverSpecial i_targetType,
+                               deviceOp_t i_regRoute)
+        __attribute__((alias("DeviceFW_deviceRegisterRoute")));
+
+    /** @brief Wrapper function to call singleton instance for performOp.
+     *
+     *  This is defined as an extern "C" function so that it can be aliased
+     *  by the template type-safe implementations of deviceOp().
+     *  This causes the compiler to generate just a single copy of the code.
+     */
+    extern "C"
+    errlHndl_t DeviceFW_deviceOp(OperationType i_opType,
+                                 TargetHandle_t i_target,
+                                 void* io_buffer, size_t& io_buflen,
+                                 int64_t i_accessType, ...)
     {
         va_list args;
         errlHndl_t errl;
@@ -133,25 +110,25 @@ namespace DeviceFW
 
         va_end(args);
         return errl;
+
     }
 
+    // deviceOp:
+    //          OpType - OperationType only.
+    //          TargType - TargetType only.
+    //          AccType - AccessType, AccessType_DriverOnly (no WILDCARD).
     template <> 
     errlHndl_t deviceOp<>(OperationType i_opType,
                           TargetHandle_t i_target,
                           void* io_buffer, size_t& io_buflen,
-                          AccessType_DriverOnly i_accessType, ...)
-    {
-        va_list args;
-        errlHndl_t errl;
-
-        va_start(args, i_accessType);
-
-        errl = Singleton<Associator>::instance().performOp(
-                i_opType, i_target, io_buffer, io_buflen,
-                i_accessType, args);
+                          AccessType i_accessType, ...)
+        __attribute__((alias("DeviceFW_deviceOp")));
 
-        va_end(args);
-        return errl;
-    }
+    template <> 
+    errlHndl_t deviceOp<>(OperationType i_opType,
+                          TargetHandle_t i_target,
+                          void* io_buffer, size_t& io_buflen,
+                          AccessType_DriverOnly i_accessType, ...)
+        __attribute__((alias("DeviceFW_deviceOp")));        
 
 };