return 1;
case IS_OP:
return 2;
+ case JUMP:
+ return 0;
case JUMP_BACKWARD:
return 0;
case JUMP_BACKWARD_NO_INTERRUPT:
return 0;
case JUMP_FORWARD:
return 0;
+ case JUMP_NO_INTERRUPT:
+ return 0;
case LIST_APPEND:
return 2 + (oparg-1);
case LIST_EXTEND:
return 1;
case LOAD_BUILD_CLASS:
return 0;
+ case LOAD_CLOSURE:
+ return 0;
case LOAD_COMMON_CONSTANT:
return 0;
case LOAD_CONST:
return 1;
case NOP:
return 0;
+ case POP_BLOCK:
+ return 0;
case POP_EXCEPT:
return 1;
case POP_JUMP_IF_FALSE:
return 2;
case SETUP_ANNOTATIONS:
return 0;
+ case SETUP_CLEANUP:
+ return 0;
+ case SETUP_FINALLY:
+ return 0;
+ case SETUP_WITH:
+ return 0;
case SET_ADD:
return 2 + (oparg-1);
case SET_FUNCTION_ATTRIBUTE:
return 1;
case STORE_FAST_LOAD_FAST:
return 1;
+ case STORE_FAST_MAYBE_NULL:
+ return 1;
case STORE_FAST_STORE_FAST:
return 2;
case STORE_GLOBAL:
return 0;
case IS_OP:
return 1;
+ case JUMP:
+ return 0;
case JUMP_BACKWARD:
return 0;
case JUMP_BACKWARD_NO_INTERRUPT:
return 0;
case JUMP_FORWARD:
return 0;
+ case JUMP_NO_INTERRUPT:
+ return 0;
case LIST_APPEND:
return 1 + (oparg-1);
case LIST_EXTEND:
return 1 + (oparg & 1);
case LOAD_BUILD_CLASS:
return 1;
+ case LOAD_CLOSURE:
+ return 1;
case LOAD_COMMON_CONSTANT:
return 1;
case LOAD_CONST:
return 2;
case NOP:
return 0;
+ case POP_BLOCK:
+ return 0;
case POP_EXCEPT:
return 0;
case POP_JUMP_IF_FALSE:
return 2;
case SETUP_ANNOTATIONS:
return 0;
+ case SETUP_CLEANUP:
+ return 2;
+ case SETUP_FINALLY:
+ return 1;
+ case SETUP_WITH:
+ return 1;
case SET_ADD:
return 1 + (oparg-1);
case SET_FUNCTION_ATTRIBUTE:
return 0;
case STORE_FAST_LOAD_FAST:
return 1;
+ case STORE_FAST_MAYBE_NULL:
+ return 0;
case STORE_FAST_STORE_FAST:
return 0;
case STORE_GLOBAL:
def test_pseudo_instruction_no_flags(self):
input = """
- pseudo(OP) = {
+ pseudo(OP, (in -- out1, out2)) = {
OP1,
};
def test_pseudo_instruction_with_flags(self):
input = """
- pseudo(OP, (HAS_ARG, HAS_JUMP)) = {
+ pseudo(OP, (in1, in2 --), (HAS_ARG, HAS_JUMP)) = {
OP1,
};
--- /dev/null
+Generate stack effect metadata for pseudo instructions from bytecodes.c.
}
}
- pseudo(LOAD_CLOSURE) = {
+ pseudo(LOAD_CLOSURE, (-- unused)) = {
LOAD_FAST,
};
SETLOCAL(oparg, value);
}
- pseudo(STORE_FAST_MAYBE_NULL) = {
+ pseudo(STORE_FAST_MAYBE_NULL, (unused --)) = {
STORE_FAST,
};
#endif /* _Py_TIER2 */
}
- pseudo(JUMP) = {
+ pseudo(JUMP, (--)) = {
JUMP_FORWARD,
JUMP_BACKWARD,
};
- pseudo(JUMP_NO_INTERRUPT) = {
+ pseudo(JUMP_NO_INTERRUPT, (--)) = {
JUMP_FORWARD,
JUMP_BACKWARD_NO_INTERRUPT,
};
ERROR_IF(res == NULL, error);
}
- pseudo(SETUP_FINALLY, (HAS_ARG)) = {
+ pseudo(SETUP_FINALLY, (-- unused), (HAS_ARG)) = {
+ /* If an exception is raised, restore the stack position
+ * and push one value before jumping to the handler.
+ */
NOP,
};
- pseudo(SETUP_CLEANUP, (HAS_ARG)) = {
+ pseudo(SETUP_CLEANUP, (-- unused, unused), (HAS_ARG)) = {
+ /* As SETUP_FINALLY, but push lasti as well */
NOP,
};
- pseudo(SETUP_WITH, (HAS_ARG)) = {
+ pseudo(SETUP_WITH, (-- unused), (HAS_ARG)) = {
+ /* If an exception is raised, restore the stack position to the
+ * position before the result of __(a)enter__ and push 2 values
+ * before jumping to the handler.
+ */
NOP,
};
- pseudo(POP_BLOCK) = {
+ pseudo(POP_BLOCK, (--)) = {
NOP,
};
static int
stack_effect(int opcode, int oparg, int jump)
{
- if (0 <= opcode && opcode <= MAX_REAL_OPCODE) {
- if (_PyOpcode_Deopt[opcode] != opcode) {
- // Specialized instructions are not supported.
- return PY_INVALID_STACK_EFFECT;
- }
- int popped = _PyOpcode_num_popped(opcode, oparg);
- int pushed = _PyOpcode_num_pushed(opcode, oparg);
- if (popped < 0 || pushed < 0) {
- return PY_INVALID_STACK_EFFECT;
- }
- return pushed - popped;
+ if (opcode < 0) {
+ return PY_INVALID_STACK_EFFECT;
}
-
- // Pseudo ops
- switch (opcode) {
- case POP_BLOCK:
- case JUMP:
- case JUMP_NO_INTERRUPT:
- return 0;
-
- /* Exception handling pseudo-instructions */
- case SETUP_FINALLY:
- /* 0 in the normal flow.
- * Restore the stack position and push 1 value before jumping to
- * the handler if an exception be raised. */
- return jump ? 1 : 0;
- case SETUP_CLEANUP:
- /* As SETUP_FINALLY, but pushes lasti as well */
- return jump ? 2 : 0;
- case SETUP_WITH:
- /* 0 in the normal flow.
- * Restore the stack position to the position before the result
- * of __(a)enter__ and push 2 values before jumping to the handler
- * if an exception be raised. */
- return jump ? 1 : 0;
-
- case STORE_FAST_MAYBE_NULL:
- return -1;
- case LOAD_CLOSURE:
- return 1;
- default:
- return PY_INVALID_STACK_EFFECT;
+ if ((opcode <= MAX_REAL_OPCODE) && (_PyOpcode_Deopt[opcode] != opcode)) {
+ // Specialized instructions are not supported.
+ return PY_INVALID_STACK_EFFECT;
}
-
- return PY_INVALID_STACK_EFFECT; /* not reachable */
+ int popped = _PyOpcode_num_popped(opcode, oparg);
+ int pushed = _PyOpcode_num_pushed(opcode, oparg);
+ if (popped < 0 || pushed < 0) {
+ return PY_INVALID_STACK_EFFECT;
+ }
+ if (IS_BLOCK_PUSH_OPCODE(opcode) && !jump) {
+ return 0;
+ }
+ return pushed - popped;
}
int
@dataclass
class PseudoInstruction:
name: str
+ stack: StackEffect
targets: list[Instruction]
flags: list[str]
opcode: int = -1
item.name, item.type, cond, (item.size or "1")
)
-def analyze_stack(op: parser.InstDef, replace_op_arg_1: str | None = None) -> StackEffect:
+def analyze_stack(op: parser.InstDef | parser.Pseudo, replace_op_arg_1: str | None = None) -> StackEffect:
inputs: list[StackItem] = [
convert_stack_item(i, replace_op_arg_1) for i in op.inputs if isinstance(i, parser.StackEffect)
]
) -> None:
pseudos[pseudo.name] = PseudoInstruction(
pseudo.name,
+ analyze_stack(pseudo),
[instructions[target] for target in pseudo.targets],
pseudo.flags,
)
"family" "(" NAME ")" = "{" NAME ("," NAME)+ [","] "}" ";"
pseudo:
- "pseudo" "(" NAME ")" = "{" NAME ("," NAME)+ [","] "}" ";"
+ "pseudo" "(" NAME "," stack_effect ["," "(" flags ")"]")" = "{" NAME ("," NAME)+ [","] "}" ";"
+
+ flags:
+ flag ("|" flag)*
+
+ flag:
+ HAS_ARG | HAS_DEOPT | etc..
```
The following definitions may occur:
from analyzer import (
Analysis,
Instruction,
+ PseudoInstruction,
analyze_files,
Skip,
Uop,
def generate_stack_effect_functions(analysis: Analysis, out: CWriter) -> None:
popped_data: list[tuple[str, str]] = []
pushed_data: list[tuple[str, str]] = []
- for inst in analysis.instructions.values():
+ def add(inst: Instruction | PseudoInstruction) -> None:
stack = get_stack_effect(inst)
popped = (-stack.base_offset).to_c()
pushed = (stack.top_offset - stack.base_offset).to_c()
popped_data.append((inst.name, popped))
pushed_data.append((inst.name, pushed))
+
+ for inst in analysis.instructions.values():
+ add(inst)
+ for pseudo in analysis.pseudos.values():
+ add(pseudo)
+
emit_stack_effect_function(out, "popped", sorted(popped_data))
emit_stack_effect_function(out, "pushed", sorted(pushed_data))
@dataclass
class Pseudo(Node):
name: str
+ inputs: list[InputEffect]
+ outputs: list[OutputEffect]
flags: list[str] # instr flags to set on the pseudo instruction
targets: list[str] # opcodes this can be replaced by
if self.expect(lx.LPAREN):
if tkn := self.expect(lx.IDENTIFIER):
if self.expect(lx.COMMA):
- flags = self.flags()
- else:
- flags = []
- if self.expect(lx.RPAREN):
- if self.expect(lx.EQUALS):
- if not self.expect(lx.LBRACE):
- raise self.make_syntax_error("Expected {")
- if members := self.members():
- if self.expect(lx.RBRACE) and self.expect(lx.SEMI):
- return Pseudo(tkn.text, flags, members)
+ inp, outp = self.io_effect()
+ if self.expect(lx.COMMA):
+ flags = self.flags()
+ else:
+ flags = []
+ if self.expect(lx.RPAREN):
+ if self.expect(lx.EQUALS):
+ if not self.expect(lx.LBRACE):
+ raise self.make_syntax_error("Expected {")
+ if members := self.members():
+ if self.expect(lx.RBRACE) and self.expect(lx.SEMI):
+ return Pseudo(tkn.text, inp, outp, flags, members)
return None
def members(self) -> list[str] | None:
import re
-from analyzer import StackItem, Instruction, Uop
+from analyzer import StackItem, StackEffect, Instruction, Uop, PseudoInstruction
from dataclasses import dataclass
from cwriter import CWriter
+from typing import Iterator
UNUSED = {"unused"}
return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */"
-def get_stack_effect(inst: Instruction) -> Stack:
+def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack:
stack = Stack()
- for uop in inst.parts:
- if not isinstance(uop, Uop):
- continue
- for var in reversed(uop.stack.inputs):
+ def stacks(inst : Instruction | PseudoInstruction) -> Iterator[StackEffect]:
+ if isinstance(inst, Instruction):
+ for uop in inst.parts:
+ if isinstance(uop, Uop):
+ yield uop.stack
+ else:
+ assert isinstance(inst, PseudoInstruction)
+ yield inst.stack
+
+ for s in stacks(inst):
+ for var in reversed(s.inputs):
stack.pop(var)
- for i, var in enumerate(uop.stack.outputs):
+ for var in s.outputs:
stack.push(var)
return stack
projects / thirdparty / Python / cpython.git / commitdiff
