refactor common code to optimize_dict_known_hash

Author: kumaraditya303

Python/optimizer_analysis.c

@@ -348,6 +348,33 @@ optimize_to_bool(
     return 0;
 }
 
+static void
+optimize_dict_known_hash(
+    JitOptContext *ctx, _PyBloomFilter *dependencies, _PyUOpInstruction *this_instr,
+    PyObject *sub, uint16_t opcode)
+{
+    if (PyUnicode_CheckExact(sub) || PyLong_CheckExact(sub) || PyBytes_CheckExact(sub)
+            || PyFloat_CheckExact(sub) || PyComplex_CheckExact(sub)) {
+        // PyObject_Hash can't fail on these types
+        ADD_OP(opcode, 0, PyObject_Hash(sub));
+    }
+    else if (PyTuple_CheckExact(sub)) {
+        // only use known hash variant when hash of tuple is already computed
+        // since computing it can call arbitrary code
+        Py_hash_t hash = ((PyTupleObject *)sub)->ob_hash;
+        if (hash != -1) {
+            ADD_OP(opcode, 0, hash);
+        }
+    }
+    else if (Py_TYPE(sub)->tp_hash == PyBaseObject_Type.tp_hash) {
+        // for user-defined objects which don't override tp_hash
+        Py_hash_t hash = PyObject_Hash(sub);
+        ADD_OP(opcode, 0, hash);
+        PyType_Watch(TYPE_WATCHER_ID, (PyObject *)Py_TYPE(sub));
+        _Py_BloomFilter_Add(dependencies, Py_TYPE(sub));
+    }
+}
+
 static void
 eliminate_pop_guard(_PyUOpInstruction *this_instr, JitOptContext *ctx, bool exit)
 {

Python/optimizer_bytecodes.c

@@ -167,26 +167,8 @@ dummy_func(void) {
     op(_STORE_SUBSCR_DICT, (value, dict_st, sub -- st)) {
         PyObject *sub_o = sym_get_const(ctx, sub);
         if (sub_o != NULL) {
-            if (PyUnicode_CheckExact(sub_o) || PyLong_CheckExact(sub_o) || PyBytes_CheckExact(sub_o)
-                || PyFloat_CheckExact(sub_o) || PyComplex_CheckExact(sub_o)) {
-                // PyObject_Hash can't fail on these types
-                ADD_OP(_STORE_SUBSCR_DICT_KNOWN_HASH, 0, PyObject_Hash(sub_o));
-            }
-            else if (PyTuple_CheckExact(sub_o)) {
-                // only use known hash variant when hash of tuple is already computed
-                // since computing it can call arbitrary code
-                Py_hash_t hash = ((PyTupleObject *)sub_o)->ob_hash;
-                if (hash != -1) {
-                    ADD_OP(_STORE_SUBSCR_DICT_KNOWN_HASH, 0, hash);
-                }
-            }
-            else if (Py_TYPE(sub_o)->tp_hash == PyBaseObject_Type.tp_hash) {
-                // for user-defined objects which don't override tp_hash
-                Py_hash_t hash = PyObject_Hash(sub_o);
-                ADD_OP(_STORE_SUBSCR_DICT_KNOWN_HASH, 0, hash);
-                PyType_Watch(TYPE_WATCHER_ID, Py_TYPE(sub_o));
-                _Py_BloomFilter_Add(dependencies, Py_TYPE(sub_o));
-            }
+            optimize_dict_known_hash(ctx, dependencies, this_instr,
+                                     sub_o, _STORE_SUBSCR_DICT_KNOWN_HASH);
         }
         (void)value;
         st = dict_st;
@@ -507,26 +489,8 @@ dummy_func(void) {
     op(_BINARY_OP_SUBSCR_DICT, (dict_st, sub_st -- res, ds, ss)) {
         PyObject *sub = sym_get_const(ctx, sub_st);
         if (sub != NULL) {
-            if (PyUnicode_CheckExact(sub) || PyLong_CheckExact(sub) || PyBytes_CheckExact(sub)
-                    || PyFloat_CheckExact(sub) || PyComplex_CheckExact(sub)) {
-                // PyObject_Hash can't fail on these types
-                ADD_OP(_BINARY_OP_SUBSCR_DICT_KNOWN_HASH, 0, PyObject_Hash(sub));
-            }
-            else if (PyTuple_CheckExact(sub)) {
-                // only use known hash variant when hash of tuple is already computed
-                // since computing it can call arbitrary code
-                Py_hash_t hash = ((PyTupleObject *)sub)->ob_hash;
-                if (hash != -1) {
-                    ADD_OP(_BINARY_OP_SUBSCR_DICT_KNOWN_HASH, 0, hash);
-                }
-            }
-            else if (Py_TYPE(sub)->tp_hash == PyBaseObject_Type.tp_hash) {
-                // for user-defined objects which don't override tp_hash
-                Py_hash_t hash = PyObject_Hash(sub);
-                ADD_OP(_BINARY_OP_SUBSCR_DICT_KNOWN_HASH, 0, hash);
-                PyType_Watch(TYPE_WATCHER_ID, Py_TYPE(sub));
-                _Py_BloomFilter_Add(dependencies, Py_TYPE(sub));
-            }
+            optimize_dict_known_hash(ctx, dependencies, this_instr,
+                                     sub, _BINARY_OP_SUBSCR_DICT_KNOWN_HASH);
         }
         res = sym_new_not_null(ctx);
         ds = dict_st;