Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "reg", ";" ]

[ "if", "(", "!", "CONST_OK_FOR_K", "(", "amount", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "inc", "=", "emit_move_insn", "(", "reg", ",", "inc", ")", ";", "if", "(", "in_prologue", ")", "F", "(", "inc", ")", ";", "inc", "=" ]

[ "void", "Thumb2HazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "ITBlockSize", ")", "{", "--", "ITBlockSize", ";", "}", "else", "if", "(", "Opcode", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumTZ", "=", "CountTrailingZeros_32", "(", "Mask", ")", ";", "assert", "(", "NumTZ", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid IT mask!", "<STR_LIT>", ")", ";", "ITBlockSize", "=", "<NUM_LIT>", "-", "NumTZ", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "ITBlockSize", ";", "++", "i", ")", "{", "do", "{", "++", "I", ";", "}", "while", "(", "I", "->", "isDebugValue", "(", ")", ")", ";", "ITBlockMIs", "[", "ITBlockSize", "-", "<NUM_LIT>", "-", "i", "]", "=", "&", "*", "I", ";", "}", "}", "PostRAHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=" ]

[ "}", ")" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "t", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "t", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "t", ",", "<NUM_LIT>", ")" ]

[ "<STR_LIT>" ]

[ "(", "unspec", ":", "SF", "[", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_FHSUB", ")", ")", "]", "<STR_LIT>" ]

[ "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "]" ]

[ "(", "cond", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "geu", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")" ]

[ "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ";" ]

[ "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code" ]

[ "V2DI", "V2DF", "]", ")" ]

[ "(", "define_mode_iterator", "VEC_64", "[" ]

[ ">", "src0_rel", ";" ]

[ "class", "R600_ALU_LDS_Word0", "{", "field", "bits", "<", "<NUM_LIT>", ">", "Word0", ";", "bits", "<", "<NUM_LIT>", ">", "src0", ";", "bits", "<", "<NUM_LIT>" ]

[ "=", "<STR_LIT>", ";" ]

[ "def", "J2_jumpf", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_db2bce9c", ",", "TypeJ", ">", ",", "Enc_daea09", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode" ]

[ "reg", "=", "thumb_find_work_register", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";" ]

[ "if", "(", "IS_NAKED", "(", "func_type", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", ")", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ")", "|", "(", "<NUM_LIT>", "<<", "IP_REGNUM", ")", "|", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", "|", "(", "<NUM_LIT>", "<<", "PC_REGNUM", ")", ";", "save_reg_mask", "|=", "arm_compute_save_reg0_reg12_mask", "(", ")", ";", "if", "(", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", "||", "(", "save_reg_mask", "&&", "optimize_size", "&&", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_NORMAL", "&&", "!", "crtl", "->", "tail_call_emit", "&&", "!", "crtl", "->", "calls_eh_return", ")", ")", "save_reg_mask", "|=", "<NUM_LIT>", "<<", "LR_REGNUM", ";", "if", "(", "cfun", "->", "machine", "->", "lr_save_eliminated", ")", "save_reg_mask", "&=", "~", "(", "<NUM_LIT>", "<<", "LR_REGNUM", ")", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "(", "(", "bit_count", "(", "save_reg_mask", ")", "+", "ARM_NUM_INTS", "(", "crtl", "->", "args", ".", "pretend_args_size", "+", "arm_compute_static_chain_stack_bytes", "(", ")", ")", ")", "%", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "{", "for", "(", "reg", "=", "<NUM_LIT>", ";", "reg", "<=", "<NUM_LIT>", ";", "reg", "++", ")", "if", "(", "(", "save_reg_mask", "&", "(", "<NUM_LIT>", "<<", "reg", ")", ")", "==", "<NUM_LIT>", ")", "break", ";", "if", "(", "reg", "<=", "<NUM_LIT>", ")", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "reg", ")", ";", "else", "{", "cfun", "->", "machine", "->", "sibcall_blocked", "=", "<NUM_LIT>", ";", "save_reg_mask", "|=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";", "}", "}", "if", "(", "TARGET_THUMB2", "&&", "IS_NESTED", "(", "func_type", ")", "&&", "flag_pic", "&&", "(", "save_reg_mask", "&", "THUMB2_WORK_REGS", ")", "==", "<NUM_LIT>", ")", "{" ]

[ "case", "UNSPECV_CONST_END", ":" ]

[ "rtx_insn", "*", "insn", ",", "*", "lab", ";", "rtx", "pattern", ";", "if", "(", "x", "==", "NULL_RTX", ")", "return", "x", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "case", "CODE_LABEL", ":", "break", ";", "default", ":", "return", "x", ";", "}", "lab", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "x", ")", ";", "for", "(", "insn", "=", "PREV_INSN", "(", "lab", ")", ";", "insn", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "LABEL_P", "(", "insn", ")", "||", "LABEL_REFS", "(", "insn", ")", "!=", "NEXT_INSN", "(", "insn", ")", ")", "break", ";", "lab", "=", "insn", ";", "}", "for", "(", "rtx", "insn", "=", "LABEL_REFS", "(", "lab", ")", ";", "insn", ";", "insn", "=", "LABEL_REFS", "(", "insn", ")", ")", "as_a", "<", "rtx_insn", "*", ">", "(", "insn", ")", "->", "set_deleted", "(", ")", ";", "for", "(", "insn", "=", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "x", ")", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "UNSPEC_VOLATILE", ")", "continue", ";", "switch", "(", "XINT", "(", "pattern", ",", "<NUM_LIT>", ")", ")", "{", "case", "UNSPECV_CONST2", ":", "case", "UNSPECV_CONST4", ":", "case", "UNSPECV_CONST8", ":", "XVECEXP", "(", "pattern", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "=", "const1_rtx", ";", "break", ";", "case", "UNSPECV_WINDOW_END", ":", "if", "(", "XVECEXP", "(", "pattern", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "==", "x", ")", "return", "lab", ";", "break", ";" ]

[ ")", "{" ]

[ "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "I", "]", ";", "SDValue", "Arg", "=", "OutVals", "[", "I", "]", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "I", "]", ".", "Flags", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "}", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "Arg", "=", "ByValArgs", "[", "J", "++", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "StackPtr", ".", "getNode", "(", ")", "==", "<NUM_LIT>", ")", "StackPtr", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ",", "StackPtr", ",", "DAG", ".", "getIntPtrConstant", "(", "VA", ".", "getLocMemOffset", "(", ")", ",", "DL", ")", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Arg", ",", "PtrOff", ",", "MachinePointerInfo", "(", ")", ")", ")", ";", "}", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "ArrayRef", "<", "SDValue", ">", "(", "&", "MemOpChains", "[", "<NUM_LIT>", "]", ",", "MemOpChains", ".", "size", "(", ")", ")", ")", ";", "SDValue", "InFlag", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "RegsToPass", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "RegsToPass", "[", "I", "]", ".", "first", ",", "RegsToPass", "[", "I", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "uint8_t", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "G" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Size", "=", "-", "Size", ";" ]

[ "MachineBasicBlock", "::", "iterator", "SparcFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "VCVT_FMODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "cvt_op", ":", "VCVT_FMODE", "(", "match_operand", ":", "VCVT_MODE", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "fputs", "(", "REGISTER_PREFIX", ",", "stream", ")", ";", "<FIXE>" ]

[ "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "<BUGS>", "fputs", "(", "ARM_REG_PREFIX", ",", "stream", ")", ";", "<BUGE>", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "stream", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")" ]

[ "let", "addrMode", "=", "PostInc", ";" ]

[ "def", "L2_ploadrubfnew_pi", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pt4", ",", "IntRegs", ":", "$", "Rx32in", ",", "s4_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_e9f3243f", ",", "TypeLD", ">", ",", "Enc_f4413a", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "callee_offset", ")", ")", ")", ";" ]

[ "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "frame_size", ">", "PROBE_INTERVAL", "&&", "frame_size", ">", "STACK_CHECK_PROTECT", ")", "aarch64_emit_probe_stack_range", "(", "STACK_CHECK_PROTECT", ",", "frame_size", "-", "STACK_CHECK_PROTECT", ")", ";", "}", "else", "if", "(", "frame_size", ">", "<NUM_LIT>", ")", "aarch64_emit_probe_stack_range", "(", "STACK_CHECK_PROTECT", ",", "frame_size", ")", ";", "}", "aarch64_sub_sp", "(", "IP0_REGNUM", ",", "initial_adjust", ",", "true", ")", ";", "if", "(", "callee_adjust", "!=", "<NUM_LIT>", ")", "aarch64_push_regs", "(", "reg1", ",", "reg2", ",", "callee_adjust", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "callee_adjust", "==", "<NUM_LIT>", ")", "aarch64_save_callee_saves", "(", "DImode", ",", "callee_offset", ",", "R29_REGNUM", ",", "R30_REGNUM", ",", "false", ")", ";" ]

[ "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SecondImmBits", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "endBit", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "endBit", ";", "bits", "<", "<NUM_LIT>", ">", "immOpNum", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "immOpNum", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "OType", ";", "bits", "<", "<NUM_LIT>", ">", "ImmOpCount", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SecondImmOp", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "ThirdImmOp", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "FirstImmBits", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SecondImmBits", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "ThirdImmBits", "=", "<NUM_LIT>", ";", "let", "TSFlags", "{", "<NUM_LIT>", "}", "=", "HasCompositeImm", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ImmOpCount", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SecondImmOp", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "ThirdImmOp", ";", "let", "TSFlags", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "FirstImmBits", ";" ]

[ ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>" ]

[ "_", "_", "v4si", ")", "_", "_", "B", ",", "_", "_", "P", ")", ";" ]

[ "const", "_", "_", "v16qu", "_", "_", "Q", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "_", "_", "v4si", "_", "_", "C", "=", "vec_perm", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(" ]

[ "}" ]

[ "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "assert", "(", "MI", ".", "definesRegister", "(", "DestReg", ",", "nullptr", ")", "&&", "<STR_LIT>", "RESTORE_QUADWORD does not define its destination", "<STR_LIT>", ")", ";", "Register", "Reg", "=", "PPC", "::", "X0", "+", "(", "DestReg", "-", "PPC", "::", "G8p0", ")", "*", "<NUM_LIT>", ";", "bool", "IsLittleEndian", "=", "Subtarget", ".", "isLittleEndian", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "Reg", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "LD", ")", ",", "Reg", "+", "<NUM_LIT>", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";" ]

[ "Invalid type access!", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "isReg", "(", ")", "&&", "<STR_LIT>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rx32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "II", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "II", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rx32", ";" ]

[ "insn", "=", "next_nonnote_insn", "(", "insn", ")", ";" ]

[ "in_use", "|=", "EV5_E0", ";", "break", ";", "case", "EV5_E1", ":", "if", "(", "in_use", "&", "EV5_E1", ")", "goto", "done", ";", "in_use", "|=", "EV5_E1", ";", "break", ";", "case", "EV5_FAM", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "{", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "}", "else", "in_use", "|=", "EV5_FA", "|", "EV5_FAM", ";", "break", ";", "case", "EV5_FA", ":", "if", "(", "in_use", "&", "EV5_FA", ")", "goto", "done", ";", "in_use", "|=", "EV5_FA", ";", "break", ";", "case", "EV5_FM", ":", "if", "(", "in_use", "&", "EV5_FM", ")", "goto", "done", ";", "in_use", "|=", "EV5_FM", ";", "break", ";", "case", "EV5_NONE", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "len", "+=", "<NUM_LIT>", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "goto", "next_and_done", ";", "next", ":" ]

[ "switch", "(", "cond", ")", "{" ]

[ "emit_insn", "(", "gen_cmpdf_le_insn", "(", "op0", ",", "op1", ")", ")", ";", "break", ";", "case", "GE", ":", "emit_insn", "(", "gen_cmpdf_ge_insn", "(", "op0", ",", "op1", ")", ")", ";", "break", ";", "case", "LT", ":", "emit_insn", "(", "gen_cmpdf_lt_insn", "(", "op0", ",", "op1", ")", ")", ";", "break", ";", "case", "GT", ":", "emit_insn", "(", "gen_cmpdf_gt_insn", "(", "op0", ",", "op1", ")", ")", ";", "break", ";", "case", "NE", ":", "case", "EQ", ":", "emit_insn", "(", "gen_cmpdf_eq_insn", "(", "op0", ",", "op1", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "mode", "==", "SFmode", ")", "{" ]

[ "m512h", "_", "_", "C", ",", "_", "_", "m512h", "_", "_", "D", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_fcmadd_pch", "(", "_", "_", "mmask16", "_", "_", "A", ",", "_", "_", "m512h", "_", "_", "B", ",", "_", "_" ]

[ "<STR_LIT>" ]

[ "(", "neg", ":", "SF", "(", "abs", ":", "SF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "Imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Imm", ";" ]

[ "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDIThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDI", ")", ";" ]

[ "if", "(", "Is64Bit", ")", "{", "assert", "(", "MF", ".", "getName", "(", ")", "==", "<STR_LIT>", "__llvm_retpoline_r11", "<STR_LIT>", "&&", "<STR_LIT>", "Should only have an r11 thunk on 64-bit targets", "<STR_LIT>", ")", ";", "populateThunk", "(", "MF", ",", "X86", "::", "R11", ")", ";", "}", "else", "{", "if", "(", "MF", ".", "getName", "(", ")", "==", "EAXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EAX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "ECXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "ECX", ")", ";", "else", "if", "(", "MF", ".", "getName", "(", ")", "==", "EDXThunkName", ")", "populateThunk", "(", "MF", ",", "X86", "::", "EDX", ")", ";" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "base", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "dst", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_bypass", "<NUM_LIT>", "<STR_LIT>" ]

[ "+", "num_arg_regs", "-", "<NUM_LIT>", "&&", "last", ">=", "GPR2_REGNUM", ")", ";" ]

[ "static", "inline", "bool", "s390_preserve_gpr_arg_in_range_p", "(", "int", "first", ",", "int", "last", ")", "{", "int", "num_arg_regs", "=", "MIN", "(", "crtl", "->", "args", ".", "info", ".", "gprs", "+", "cfun", "->", "va_list_gpr_size", ",", "GP_ARG_NUM_REG", ")", ";", "return", "(", "num_arg_regs", "&&", "s390_preserve_args_p", "&&", "first", "<=", "GPR2_REGNUM" ]

[ "bool", "SparcAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "SmallVector", "<", "MCInst", ",", "<NUM_LIT>", ">", "Instructions", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "instruction requires a CPU feature not currently enabled", "<STR_LIT>", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "<NUM_LIT>", "ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "too few operands for instruction", "<STR_LIT>", ")", ";", "ErrorLoc", "=", "(", "(", "SparcOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "<STR_LIT>", "invalid operand for instruction", "<STR_LIT>", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "<STR_LIT>", "invalid instruction mnemonic", "<STR_LIT>", ")", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "Implement any new match types added!", "<STR_LIT>", ")", ";", "}" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Inst32", ".", "add", "(", "*", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ";" ]

[ "MachineInstr", "*", "SIInstrInfo", "::", "buildShrunkInst", "(", "MachineInstr", "&", "MI", ",", "unsigned", "Op32", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", ";", "MachineInstrBuilder", "Inst32", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "Op32", ")", ")", ";", "int", "Op32DstIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Op32", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "if", "(", "Op32DstIdx", "!=", "-", "<NUM_LIT>", ")", "{", "Inst32", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "assert", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "&&", "<STR_LIT>", "Unexpected case", "<STR_LIT>", ")", ";", "}" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "if", "(", "&", "OneUse", ">", "&", "Use", ")", "return", "false", ";" ]

[ "if", "(", "UseInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PHI", ")", "{", "const", "MachineBasicBlock", "*", "Pred", "=", "UseInst", "->", "getOperand", "(", "&", "Use", "-", "&", "UseInst", "->", "getOperand", "(", "<NUM_LIT>", ")", "+", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MDT", ".", "dominates", "(", "&", "MBB", ",", "Pred", ")", ")", "return", "false", ";", "}", "else", "if", "(", "UseInst", "==", "OneUseInst", ")", "{" ]

[ "return", "std", "::", "nullopt", ";" ]

[ "std", "::", "optional", "<", "DestSourcePair", ">", "Mips16InstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";" ]

[ ";" ]

[ "LanaiMachineFunctionInfo", "*", "LanaiMFI", "=", "MF", ".", "getInfo", "<", "LanaiMachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "Fast", ")", "{", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Lanai32_Fast", ")", ";", "}", "else", "{", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Lanai32", ")", ";", "}", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i32", ":", "{", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "}", "default", ":", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "LowerFormalArguments Unhandled argument type: ", "<STR_LIT>", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "unhandled argument type", "<STR_LIT>", ")", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "if", "(", "ObjSize", ">", "<NUM_LIT>", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "LowerFormalArguments Unhandled argument type: ", "<STR_LIT>", "<<", "EVT", "(", "VA", ".", "getLocVT", "(", ")", ")", ".", "getEVTString", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VA", ".", "getLocVT", "(", ")", ",", "DL", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ")", ";", "}", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "unsigned", "Reg", "=", "LanaiMFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "{", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "MVT", "::", "i32", ")", ")", ";", "LanaiMFI", "->", "setSRetReturnReg", "(", "Reg", ")", ";", "}", "SDValue", "Copy", "=", "DAG", ".", "getCopyToReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "DL", ",", "Reg", ",", "InVals", "[", "<NUM_LIT>", "]", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "Copy", ",", "Chain", ")", ";", "}", "if", "(", "IsVarArg", ")", "{", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "<NUM_LIT>", ",", "CCInfo", ".", "getNextStackOffset", "(", ")", ",", "true", ")", ";", "LanaiMFI", "->", "setVarArgsFrameIndex", "(", "FI", ")", ";", "}", "return", "Chain" ]

[ "}" ]

[ "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", "->", "setFrameAddressIsTaken", "(", "true", ")", ";", "bool", "is31", "=", "(", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "&&", "MFI", "->", "getStackSize", "(", ")", "&&", "!", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttr", "(", "Attribute", "::", "Naked", ")", ";", "unsigned", "FrameReg", "=", "isPPC64", "?", "(", "is31", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ")", ":", "(", "is31", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ")", ";", "SDValue", "FrameAddr", "=", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "FrameReg", ",", "PtrVT", ")", ";", "while", "(", "Depth", "--", ")", "FrameAddr", "=", "DAG", ".", "getLoad", "(", "Op", ".", "getValueType", "(", ")", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "FrameAddr", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "return", "FrameAddr", ";" ]

[ "::", "JRC16_MM", ")", ";" ]

[ "Iter", "Filler", "::", "replaceWithCompactJump", "(", "MachineBasicBlock", "&", "MBB", ",", "Iter", "Jump", ",", "DebugLoc", "DL", ")", "{", "const", "MipsInstrInfo", "*", "TII", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "NewDesc", "=", "TII", "->", "get", "(", "Mips" ]

[ "<STR_LIT>", ";" ]

[ "def", "BranchTarget26Operand", ":", "AsmOperandClass", "{", "let", "Name", "=" ]

[ ")", "CPU", "=", "<STR_LIT>", "mips32", "<STR_LIT>", ";" ]

[ "if", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips", "||", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mipsel" ]

[ "LaneVGPR", ",", "None", ")", ")", ";" ]

[ "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Register", "LaneVGPR", "=", "TRI", "->", "findUnusedRegister", "(", "MF", ".", "getRegInfo", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "MF", ",", "true", ")", ";", "if", "(", "LaneVGPR", "==", "Register", "(", ")", ")", "return", "false", ";", "SpillVGPRs", ".", "push_back", "(", "SGPRSpillVGPR", "(" ]

[ "static", "int", "arm_needs_doubleword_align", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "!", "type", ")", "return", "GET_MODE_ALIGNMENT", "(", "mode", ")", ">", "PARM_BOUNDARY", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ">", "PARM_BOUNDARY", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "return", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "type", ")", ")", ">", "PARM_BOUNDARY", ";", "int", "ret", "=", "<NUM_LIT>", ";", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "DECL_ALIGN", "(", "field", ")", ">", "PARM_BOUNDARY", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "return", "<NUM_LIT>", ";", "else", "ret", "=", "-", "<NUM_LIT>", ";", "}", "return", "ret", ";", "}" ]

[ "Return", "1", "if", "double", "word", "alignment", "is", "required", "for", "argument", "passing", ".", "Return", "-1", "if", "double", "word", "alignment", "used", "to", "be", "required", "for", "argument", "passing", "before", "PR77728", "ABI", "fix", ",", "but", "is", "not", "required", "anymore", ".", "Return", "0", "if", "double", "word", "alignment", "is", "not", "required", "and", "was", "n't", "requried", "before", "either", "." ]

[ "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>" ]

[ ",", "V1InUse", ",", "V2InUse", ")", ";" ]

[ "static", "SDValue", "lowerV64I8Shuffle", "(", "const", "SDLoc", "&", "DL", ",", "ArrayRef", "<", "int", ">", "Mask", ",", "const", "APInt", "&", "Zeroable", ",", "SDValue", "V1", ",", "SDValue", "V2", ",", "const", "X86Subtarget", "&", "Subtarget", ",", "SelectionDAG", "&", "DAG", ")", "{", "assert", "(", "V1", ".", "getSimpleValueType", "(", ")", "==", "MVT", "::", "v64i8", "&&", "<STR_LIT>", "Bad operand type!", "<STR_LIT>", ")", ";", "assert", "(", "V2", ".", "getSimpleValueType", "(", ")", "==", "MVT", "::", "v64i8", "&&", "<STR_LIT>", "Bad operand type!", "<STR_LIT>", ")", ";", "assert", "(", "Mask", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected mask size for v64 shuffle!", "<STR_LIT>", ")", ";", "assert", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "<STR_LIT>", "We can only lower v64i8 with AVX-512-BWI!", "<STR_LIT>", ")", ";", "if", "(", "SDValue", "ZExt", "=", "lowerShuffleAsZeroOrAnyExtend", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "ZExt", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleWithUNPCK", "(", "DL", ",", "MVT", "::", "v64i8", ",", "Mask", ",", "V1", ",", "V2", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleWithPACK", "(", "DL", ",", "MVT", "::", "v64i8", ",", "Mask", ",", "V1", ",", "V2", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "if", "(", "SDValue", "Shift", "=", "lowerShuffleAsShift", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ",", "false", ")", ")", "return", "Shift", ";", "if", "(", "SDValue", "Rotate", "=", "lowerShuffleAsByteRotate", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";", "if", "(", "V2", ".", "isUndef", "(", ")", ")", "if", "(", "SDValue", "Rotate", "=", "lowerShuffleAsBitRotate", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Rotate", ";", "if", "(", "SDValue", "Masked", "=", "lowerShuffleAsBitMask", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Masked", ";", "if", "(", "SDValue", "PSHUFB", "=", "lowerShuffleWithPSHUFB", "(", "DL", ",", "MVT", "::", "v64i8", ",", "Mask", ",", "V1", ",", "V2", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "PSHUFB", ";", "if", "(", "SDValue", "V", "=", "lowerShuffleAsRepeatedMaskAndLanePermute", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "if", "(", "SDValue", "Result", "=", "lowerShuffleAsLanePermuteAndPermute", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "DAG", ",", "Subtarget", ")", ")", "return", "Result", ";", "if", "(", "SDValue", "Blend", "=", "lowerShuffleAsBlend", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "Subtarget", ",", "DAG", ")", ")", "return", "Blend", ";", "if", "(", "!", "is128BitLaneCrossingShuffleMask", "(", "MVT", "::", "v64i8", ",", "Mask", ")", ")", "{", "if", "(", "SDValue", "V", "=", "lowerShuffleAsByteRotateAndPermute", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Subtarget", ",", "DAG", ")", ")", "return", "V", ";", "bool", "V1InUse", ",", "V2InUse", ";", "return", "lowerShuffleAsBlendOfPSHUFBs", "(", "DL", ",", "MVT", "::", "v64i8", ",", "V1", ",", "V2", ",", "Mask", ",", "Zeroable", ",", "DAG" ]

[ "WriteID64", ",", "ReadID", ",", "ReadID", "]", ">", "{" ]

[ "def", "Xr", ":", "BaseDiv", "<", "isSigned", ",", "GPR64", ",", "asm", ",", "OpNode", ">", ",", "Sched", "<", "[" ]

[ "const", "char", "*", "loongarch_output_conditional_branch", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "const", "char", "*", "branch_if_true", ",", "const", "char", "*", "branch_if_false", ")", "{", "unsigned", "int", "length", ";", "rtx", "taken", ";", "gcc_assert", "(", "LABEL_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", "<=", "<NUM_LIT>", ")", "{", "return", "branch_if_true", ";", "}", "rtx_code_label", "*", "not", "_", "taken", "=", "gen_label_rtx", "(", ")", ";", "taken", "=", "operands", "[", "<NUM_LIT>", "]", ";", "operands", "[", "<NUM_LIT>", "]", "=", "not", "_", "taken", ";", "output_asm_insn", "(", "branch_if_false", ",", "operands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "b\\t%0", "<STR_LIT>", ",", "&", "taken", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "<STR_LIT>", "L", "<STR_LIT>", ",", "CODE_LABEL_NUMBER", "(", "not", "_", "taken", ")", ")", ";", "return", "<STR_LIT>", "<STR_LIT>", ";", "}" ]

[ "Return", "the", "assembly", "code", "for", "INSN", ",", "which", "has", "the", "operands", "given", "by", "OPERANDS", ",", "and", "which", "branches", "to", "OPERANDS", "[", "0", "]", "if", "some", "condition", "is", "true", ".", "BRANCH_IF_TRUE", "is", "the", "asm", "template", "that", "should", "be", "used", "if", "OPERANDS", "[", "0", "]", "is", "in", "range", "of", "a", "direct", "branch", ".", "BRANCH_IF_FALSE", "is", "an", "inverted", "version", "of", "BRANCH_IF_TRUE", "." ]

[ "SrcCIsStoreSrcCStart", ")", "&", "TPCII", "::", "SrcCIsStoreSrcCMask", ";" ]

[ "inline", "bool", "getSrcCIsStoreSrcC", "(", "const", "MCInstrDesc", "&", "MCInstD", ")", "{", "return", "(", "MCInstD", ".", "TSFlags", ">>" ]

[ "<FIXS>", ":", "A64InstRdnm", "outs", ",", "ins", ",", "asmstr", ",", "patterns", ",", "itin", ">", "{", "<FIXE>" ]

[ "class", "A64I_addsubshift", "bit", "sf", ",", "bit", "op", ",", "bit", "S", ",", "bits", "<NUM_LIT>", ">", "shift", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "dag", ">", "patterns", ",", "InstrItinClass", "itin", ">", "<BUGS>", ":", "A64InstRdnm", "outs", ",", "ins", ",", "asmstr", ",", "patterns", ",", "itin", ">", "{", "<BUGE>", "bits", "<NUM_LIT>", ">", "Imm6", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "sf", ";" ]

[ "ops", ")" ]

[ "]", "<STR_LIT>", "{", "rtx", "ops", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "output_asm_insn", "(", "<STR_LIT>", "," ]

[ "unsigned", "LanaiInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "<NUM_LIT>", ">", "Accesses", ";", "if", "(", "hasLoadFromStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "<NUM_LIT>", ";", "}", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "auto", "SuccStartState", "=", "InitialStates", ".", "find", "(", "SuccBB", ")", ";" ]

[ "if", "(", "isa", "<", "CatchReturnInst", ">", "(", "BB", "->", "getTerminator", "(", ")", ")", ")", "return", "OverdefinedState", ";", "int", "CommonState", "=", "OverdefinedState", ";", "for", "(", "BasicBlock", "*", "SuccBB", ":", "successors", "(", "BB", ")", ")", "{" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "<STR_LIT>", "<STR_LIT>", ";" ]

[ "return", "ci", ".", "getSite", "(", ")", "->", "isInSCC", "(", ")", "?", "<STR_LIT>", "style=\\\"bold\\\"", "<STR_LIT>", ":" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Imm", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "return", "false", ";" ]

[ "if", "(", "!", "insn", "||", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_sched_groups", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "type", "==", "TYPE_BRANCH", "||", "type", "==", "TYPE_JMPREG", ")", "return", "true", ";" ]

[ "<FIXS>", "static", "int", "rs6000_debug_adjust_cost", "(", "rtx_insn", "*", ",", "int", ",", "rtx_insn", "*", ",", "int", ",", "unsigned", "int", ")", ";", "<FIXE>" ]

[ "static", "bool", "rs6000_debug_rtx_costs", "(", "rtx", ",", "machine_mode", ",", "int", ",", "int", ",", "int", "*", ",", "bool", ")", ";", "static", "int", "rs6000_debug_address_cost", "(", "rtx", ",", "machine_mode", ",", "addr_space_t", ",", "bool", ")", ";", "<BUGS>", "static", "int", "rs6000_debug_adjust_cost", "(", "rtx_insn", "*", ",", "rtx", ",", "rtx_insn", "*", ",", "int", ")", ";", "<BUGE>", "static", "bool", "is_microcoded_insn", "(", "rtx_insn", "*", ")", ";", "static", "bool", "is_nonpipeline_insn", "(", "rtx_insn", "*", ")", ";", "static", "bool", "is_cracked_insn", "(", "rtx_insn", "*", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VF_128", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_REDUCE", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

[ "static", "void", "mmix_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_farp_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_sizep", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "args_so_farp", "=", "get_cumulative_args", "(", "args_so_farp_v", ")", ";", "if", "(", "args_so_farp", "->", "regs", "+", "<NUM_LIT>", "<", "MMIX_MAX_ARGS_IN_REGS", ")", "*", "pretend_sizep", "=", "(", "MMIX_MAX_ARGS_IN_REGS", "-", "(", "args_so_farp", "->", "regs", "+", "<NUM_LIT>", ")", ")", "*", "<NUM_LIT>", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", "&&", "(", "<NUM_LIT>", "+", "(", "MMIX_FUNCTION_ARG_SIZE", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", ")", "/", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "internal_error", "(", "<STR_LIT>", "MMIX Internal: Last named vararg would not fit in a register", "<STR_LIT>", ")", ";", "}" ]

[ "SETUP_INCOMING_VARARGS", "." ]

[ ";" ]

[ "def", "F2_sfcmpuo", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "IntRegs", ":", "$", "Rt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeS_3op", ">", ",", "Enc_c2b48e", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR", "]", ";", "let", "isCompare", "=", "<NUM_LIT>" ]

[ ";" ]

[ "HexagonSubtarget", "::", "HexagonSubtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "HexagonGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "CPUString", "(", "CPU", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", ")", "{", "initializeEnvironment", "(", ")" ]

[ "rtx", "base", ",", "int", "offset", ")", "{" ]

[ "static", "rtx", "frv_frame_mem", "(", "machine_mode", "mode", "," ]

[ "let", "isFP", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "num_fprs", ";" ]

[ "static", "void", "s390_frame_info", "(", "void", ")", "{", "HOST_WIDE_INT", "lowest_offset", ";", "cfun_frame_layout", ".", "first_save_gpr_slot", "=", "cfun_frame_layout", ".", "first_save_gpr", ";", "cfun_frame_layout", ".", "last_save_gpr_slot", "=", "cfun_frame_layout", ".", "last_save_gpr", ";", "if", "(", "cfun", "->", "stdarg", "&&", "cfun_save_arg_fprs_p", ")", "{", "cfun_frame_layout", ".", "last_save_gpr_slot", "=", "STACK_POINTER_REGNUM", ";", "if", "(", "cfun_frame_layout", ".", "first_save_gpr_slot", "==", "-", "<NUM_LIT>", ")", "cfun_frame_layout", ".", "first_save_gpr_slot", "=", "STACK_POINTER_REGNUM", ";", "}", "cfun_frame_layout", ".", "frame_size", "=", "get_frame_size", "(", ")", ";", "if", "(", "!", "TARGET_64BIT", "&&", "cfun_frame_layout", ".", "frame_size", ">", "<NUM_LIT>", ")", "fatal_error", "(", "input_location", ",", "<STR_LIT>", "total size of local variables exceeds architecture limit", "<STR_LIT>", ")", ";", "if", "(", "!", "TARGET_PACKED_STACK", ")", "{", "cfun_frame_layout", ".", "backchain_offset", "=", "<NUM_LIT>", ";", "cfun_frame_layout", ".", "f0_offset", "=", "<NUM_LIT>", "*", "UNITS_PER_LONG", ";", "cfun_frame_layout", ".", "f4_offset", "=", "cfun_frame_layout", ".", "f0_offset", "+", "<NUM_LIT>", "*", "<NUM_LIT>", ";", "cfun_frame_layout", ".", "f8_offset", "=", "-", "cfun_frame_layout", ".", "high_fprs", "*", "<NUM_LIT>", ";", "cfun_frame_layout", ".", "gprs_offset", "=", "(", "cfun_frame_layout", ".", "first_save_gpr_slot", "*", "UNITS_PER_LONG", ")", ";", "}", "else", "if", "(", "TARGET_BACKCHAIN", ")", "{", "gcc_assert", "(", "TARGET_SOFT_FLOAT", ")", ";", "cfun_frame_layout", ".", "backchain_offset", "=", "(", "STACK_POINTER_OFFSET", "-", "UNITS_PER_LONG", ")", ";", "cfun_frame_layout", ".", "last_save_gpr_slot", "=", "STACK_POINTER_REGNUM", ";", "cfun_frame_layout", ".", "gprs_offset", "=", "cfun_frame_layout", ".", "backchain_offset", "-", "cfun_gprs_save_area_size", ";", "cfun_frame_layout", ".", "f0_offset", "=", "cfun_frame_layout", ".", "f4_offset", "=", "cfun_frame_layout", ".", "f8_offset", "=", "cfun_frame_layout", ".", "gprs_offset", ";", "}", "else", "{", "int" ]

[ "<FIXS>", "slot0", "=", "assign_stack_temp", "(", "TFmode", ",", "GET_MODE_SIZE", "(", "TFmode", ")", ")", ";", "<FIXE>" ]

[ "}", "else", "{", "<BUGS>", "slot0", "=", "assign_stack_temp", "(", "TFmode", ",", "GET_MODE_SIZE", "(", "TFmode", ")", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "emit_move_insn", "(", "slot0", ",", "x", ")", ";", "}" ]

[ "}" ]

[ "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.arch ev6", "<STR_LIT>", ")", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "<STR_LIT>", "\\t.set noat", "<STR_LIT>", ")", ")", ";" ]

[ "}" ]

[ "while", "(", "Found", "&&", "I", "!=", "CurInst", ")", "{", "if", "(", "CurInst", "->", "isCall", "(", ")", "||", "CurInst", "->", "isInlineAsm", "(", ")", ")", "break", ";", "if", "(", "InstrDistance", ">", "INSTR_DISTANCE_THRESHOLD", ")", "break", ";", "if", "(", "usesRegister", "(", "p", ",", "CurInst", ")", "==", "RU_Write", ")", "{", "return", "CurInst", ";", "}", "InstrDistance", "+=", "TII", "->", "getInstrLatency", "(", "TM", "->", "getInstrItineraryData", "(", ")", ",", "CurInst", ")", ";", "Found", "=", "getPreviousInstr", "(", "CurInst", ",", "MFI", ")", ";", "}", "return", "<NUM_LIT>", ";" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ "(", "const_vector", ":", "V4QI", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "return", "DAG", ".", "getMemIntrinsicNode", "(", "Opc", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";" ]

[ "unsigned", "Slc", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "IdxEn", "=", "<NUM_LIT>", ";", "if", "(", "auto", "Idx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "IdxEn", "=", "Idx", "->", "getZExtValue", "(", ")", "!=", "<NUM_LIT>", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "VData", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getTargetConstant", "(", "Dfmt", "|", "(", "Nfmt", "<<", "<NUM_LIT>", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getTargetConstant", "(", "Glc", "|", "(", "Slc", "<<", "<NUM_LIT>", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getTargetConstant", "(", "IdxEn", ",", "DL", ",", "MVT", "::", "i1", ")", ",", "}", ";", "unsigned", "Opc", "=", "IsD16", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MemSDNode", "*", "M", "=", "cast", "<", "MemSDNode", ">", "(", "Op", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "Opc", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_struct_tbuffer_store", ":", "{", "SDValue", "VData", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "bool", "IsD16", "=", "(", "VData", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f16", ")", ";", "if", "(", "IsD16", ")", "VData", "=", "handleD16VData", "(", "VData", ",", "DAG", ")", ";", "auto", "Offsets", "=", "splitBufferOffsets", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "VData", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Offsets", ".", "first", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Offsets", ".", "second", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i1", ")", ",", "}", ";", "unsigned", "Opc", "=", "IsD16", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MemSDNode", "*", "M", "=", "cast", "<", "MemSDNode", ">", "(", "Op", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "Opc", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_raw_tbuffer_store", ":", "{", "SDValue", "VData", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "bool", "IsD16", "=", "(", "VData", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f16", ")", ";", "if", "(", "IsD16", ")", "VData", "=", "handleD16VData", "(", "VData", ",", "DAG", ")", ";", "auto", "Offsets", "=", "splitBufferOffsets", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "VData", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "Offsets", ".", "first", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Offsets", ".", "second", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i1", ")", ",", "}", ";", "unsigned", "Opc", "=", "IsD16", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MemSDNode", "*", "M", "=", "cast", "<", "MemSDNode", ">", "(", "Op", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "Opc", ",", "DL", ",", "Op", "->", "getVTList", "(", ")", ",", "Ops", ",", "M", "->", "getMemoryVT", "(", ")", ",", "M", "->", "getMemOperand", "(", ")", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_buffer_store", ":", "case", "Intrinsic", "::", "amdgcn_buffer_store_format", ":", "{", "SDValue", "VData", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "bool", "IsD16", "=", "(", "VData", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f16", ")", ";", "if", "(", "IsD16", ")", "VData", "=", "handleD16VData", "(", "VData", ",", "DAG", ")", ";", "unsigned", "Glc", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "Slc", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "IdxEn", "=", "<NUM_LIT>", ";", "if", "(", "auto", "Idx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "IdxEn", "=", "Idx", "->", "getZExtValue", "(", ")", "!=", "<NUM_LIT>", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "VData", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "SDValue", "(", ")", ",", "SDValue", "(", ")", ",", "SDValue", "(", ")", ",", "DAG", ".", "getTargetConstant", "(", "Glc", "|", "(", "Slc", "<<", "<NUM_LIT>", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getTargetConstant", "(", "IdxEn", ",", "DL", ",", "MVT", "::", "i1", ")", ",", "}", ";", "unsigned", "Offset", "=", "setBufferOffsets", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ",", "&", "Ops", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "IdxEn", ")", "Offset", "=", "<NUM_LIT>", ";", "unsigned", "Opc", "=", "IntrinsicID", "==", "Intrinsic", "::", "amdgcn_buffer_store", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "Opc", "=", "IsD16", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "Opc", ";", "MemSDNode", "*", "M", "=", "cast", "<", "MemSDNode", ">", "(", "Op", ")", ";", "M", "->", "getMemOperand", "(", ")", "->", "setOffset", "(", "Offset", ")", ";", "EVT", "VDataType", "=", "VData", ".", "getValueType", "(", ")", ".", "getScalarType", "(", ")", ";", "if", "(", "VDataType", "==", "MVT", "::", "i8", "||", "VDataType", "==", "MVT", "::", "i16", ")", "return", "handleByteShortBufferStores", "(", "DAG", ",", "VDataType", ",", "DL", ",", "Ops", ",", "M", ")", ";" ]

[ "==", "S", ".", "Mode", ")", ";" ]

[ "return", "(", "(", "Mask", "&", "S", ".", "Mask", ")", "==", "S", ".", "Mask", ")", "&&", "(", "(", "Mode", "&", "S", ".", "Mask", ")" ]

[ ")" ]

[ "(", "define_predicate", "<STR_LIT>", "(", "if_then_else", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>" ]

[ "if", "(", "VerifyARMPseudo", ")", "MF", ".", "verify", "(", "this", ",", "<STR_LIT>", "After expanding ARM pseudo instructions.", "<STR_LIT>", ")", ";" ]

[ "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "ExpandMBB", "(", "*", "MFI", ")", ";" ]

[ "<FIXS>", "def", "BSR", ":", "F_BRANCH", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "brtarget26", ":", "$", "d26", ")", ",", "<STR_LIT>", ">", ";", "<FIXE>", "<FIXS>", "def", "BSRn", ":", "F_BRANCH", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "brtarget26", ":", "$", "d26", ")", ",", "<STR_LIT>", ">", ";", "<FIXE>" ]

[ "let", "hasDelaySlot", "=", "<NUM_LIT>", "indef", "JSRn", ":", "F_JMP", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "GPR", ":", "$", "rs2", ")", ",", "<STR_LIT>", ">", ";", "<BUGS>", "def", "BSR", ":", "F_BRANCH", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "brtarget26", ":", "$", "d26", ")", ",", "<STR_LIT>", ",", "[", "(", "br", "bb", ":", "$", "d26", ")", "]", ">", ";", "<BUGE>", "let", "hasDelaySlot", "=", "<NUM_LIT>", "in", "<BUGS>", "def", "BSRn", ":", "F_BRANCH", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "brtarget26", ":", "$", "d26", ")", ",", "<STR_LIT>", ",", "[", "(", "br", "bb", ":", "$", "d26", ")", "]", ">", ";", "<BUGE>", "}", "let", "isReturn", "=", "<NUM_LIT>", ",", "isTerminator", "=", "<NUM_LIT>", ",", "isBarrier", "=", "<NUM_LIT>", ",", "Uses", "=", "[", "R1", "]", "in", "{" ]

[ "]", ">", ";" ]

[ "def", "S_OR_SAVEEXEC_B64", ":", "SOP1_64", "<", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[" ]

[ ",", "SUu", ")", ";" ]

[ "const", "auto", "*", "QII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "TII", ")", ";", "if", "(", "QII", "->", "mayBeCurLoad", "(", "*", "SUd", "->", "getInstr", "(", ")", ")", ")", "return", "false", ";", "if", "(", "QII", "->", "canExecuteInBundle", "(", "*", "SUd", "->", "getInstr", "(", ")", ",", "*", "SUu", "->", "getInstr", "(", ")", ")", ")", "return", "false", ";", "return", "VLIWResourceModel", "::", "hasDependence", "(", "SUd" ]

[ ",", "(", "_", "_", "mmask16", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_vpermt2varhi256_mask", "(", "(", "_", "_", "v16hi", ")", "_", "_", "I", ",", "(", "_", "_", "v16hi", ")", "_", "_", "A", ",", "(", "_", "_", "v16hi", ")", "_", "_", "B" ]

[ "(", ")", ">>", "<NUM_LIT>", ";" ]

[ "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm" ]

[ ")", ";" ]

[ "OperandMatchResultTy", "AMDGPUAsmParser", "::", "parseSymbolicOrNumericFormat", "(", "int64_t", "&", "Format", ")", "{", "using", "namespace", "llvm", "::", "AMDGPU", "::", "MTBUFFormat", ";", "if", "(", "!", "trySkipId", "(", "<STR_LIT>", "format", "<STR_LIT>", ",", "AsmToken", "::", "Colon", ")", ")", "return", "MatchOperand_NoMatch", ";", "if", "(", "trySkipToken", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "StringRef", "FormatStr", ";", "SMLoc", "Loc", "=", "getLoc", "(", ")", ";", "if", "(", "!", "parseId", "(", "FormatStr", ",", "<STR_LIT>", "expected a format string", "<STR_LIT>", ")", ")", "return", "MatchOperand_ParseFail", ";", "auto", "Res", "=", "parseSymbolicUnifiedFormat", "(", "FormatStr", ",", "Loc", ",", "Format", ")", ";", "if", "(", "Res", "==", "MatchOperand_NoMatch", ")", "Res", "=", "parseSymbolicSplitFormat", "(", "FormatStr", ",", "Loc", ",", "Format", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Res", ";", "skipToken", "(", "AsmToken", "::", "RBrac", ",", "<STR_LIT>", "expected a closing square bracket", "<STR_LIT>", ")", ";", "return", "MatchOperand_Success", ";", "}", "return", "parseNumericFormat", "(", "Format" ]

[ "return", "true", ";" ]

[ "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd16", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd16", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "IsVarArg", ")", ";" ]

[ "return", "AMDGPUCallLowering", "::", "CCAssignFnForReturn", "(", "CC", "," ]

[ "}" ]

[ "static", "bool", "glibc_supports_ieee_128bit", "(", "void", ")", "{", "if", "(", "OPTION_GLIBC", "&&", "!", "BYTES_BIG_ENDIAN", "&&", "(", "(", "TARGET_GLIBC_MAJOR", "*", "<NUM_LIT>", ")", "+", "TARGET_GLIBC_MINOR", ")", ">=", "<NUM_LIT>", ")", "return", "true", ";", "return", "false", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "find_mem_ref", "(", "rtx", "pat", ",", "rtx", "*", "mem_ref", ")", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "{", "*", "mem_ref", "=", "pat", ";", "return", "true", ";", "}", "<FIXE>", "<FIXS>", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "pat", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "i", "--", ")", "<FIXE>", "<FIXS>", "{", "if", "(", "find_mem_ref", "(", "XEXP", "(", "pat", ",", "i", ")", ",", "mem_ref", ")", ")", "return", "true", ";", "}", "<FIXE>", "<FIXS>", "{", "if", "(", "find_mem_ref", "(", "XVECEXP", "(", "pat", ",", "i", ",", "j", ")", ",", "mem_ref", ")", ")", "return", "true", ";", "}", "<FIXE>", "<FIXS>", "return", "false", ";", "<FIXE>", "<FIXS>", "is_load_insn1", "(", "rtx", "pat", ",", "rtx", "*", "load_mem", ")", "<FIXE>", "<FIXS>", "return", "find_mem_ref", "(", "SET_SRC", "(", "pat", ")", ",", "load_mem", ")", ";", "<FIXE>", "<FIXS>", "if", "(", "is_load_insn1", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "i", ")", ",", "load_mem", ")", ")", "<FIXE>" ]

[ "return", "<NUM_LIT>", ";", "}", "<BUGS>", "<BUGE>", "static", "bool", "<BUGS>", "is_mem_ref", "(", "rtx", "pat", ")", "<BUGE>", "{", "const", "char", "*", "fmt", ";", "int", "i", ",", "j", ";", "<BUGS>", "bool", "ret", "=", "false", ";", "<BUGE>", "if", "(", "tie_operand", "(", "pat", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "MEM", ")", "<BUGS>", "return", "true", ";", "<BUGE>", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "pat", ")", ")", ";", "<BUGS>", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "pat", ")", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", "&&", "!", "ret", ";", "i", "--", ")", "<BUGE>", "{", "if", "(", "fmt", "[", "i", "]", "==", "'", "e", "'", ")", "<BUGS>", "ret", "|=", "is_mem_ref", "(", "XEXP", "(", "pat", ",", "i", ")", ")", ";", "<BUGE>", "else", "if", "(", "fmt", "[", "i", "]", "==", "'", "E", "'", ")", "for", "(", "j", "=", "XVECLEN", "(", "pat", ",", "i", ")", "-", "<NUM_LIT>", ";", "j", ">=", "<NUM_LIT>", ";", "j", "--", ")", "<BUGS>", "ret", "|=", "is_mem_ref", "(", "XVECEXP", "(", "pat", ",", "i", ",", "j", ")", ")", ";", "<BUGE>", "}", "<BUGS>", "return", "ret", ";", "<BUGE>", "}", "static", "bool", "<BUGS>", "is_load_insn1", "(", "rtx", "pat", ")", "<BUGE>", "{", "if", "(", "!", "pat", "||", "pat", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "<BUGS>", "return", "is_mem_ref", "(", "SET_SRC", "(", "pat", ")", ")", ";", "<BUGE>", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "XVECLEN", "(", "pat", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "<BUGS>", "if", "(", "is_load_insn1", "(", "XVECEXP", "(", "pat", ",", "<NUM_LIT>", ",", "i", ")", ")", ")", "<BUGE>", "return", "true", ";", "}" ]

[ "<FIXS>", "unsigned", "ArgSlotSizeInBytes", "=", "(", "ABI", ".", "IsN32", "(", ")", "||", "ABI", ".", "IsN64", "(", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "<FIXE>" ]

[ "unsigned", "Align", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "const", "Value", "*", "SV", "=", "cast", "SrcValueSDNode", ">", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "<BUGS>", "unsigned", "ArgSlotSizeInBytes", "=", "(", "Subtarget", ".", "isABI_N32", "(", ")", "||", "Subtarget", ".", "isABI_N64", "(", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "<BUGE>", "SDValue", "VAListLoad", "=", "DAG", ".", "getLoad", "(", "getPointerTy", "(", ")", ",", "DL", ",", "Chain", ",", "VAListPtr", ",", "MachinePointerInfo", "(", "SV", ")", ",", "false", ",", "false", ",", "false", "," ]

[ "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "DoubleWordAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isExtendable" ]

[ "<STR_LIT>" ]

[ "(", "neg", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ ")", "{" ]

[ "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "X86MFInfo", "->", "getBytesToPopOnReturn", "(", ")", ")", ")", "return", "false", ";", "if", "(", "(", "CC", "==", "CallingConv", "::", "Fast", "&&", "TM", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "||", "CC", "==", "CallingConv", "::", "Tail", "||", "CC", "==", "CallingConv", "::", "SwiftTail", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "RetRegs", ";", "if", "(", "Ret", "->", "getNumOperands", "(", ")", ">", "<NUM_LIT>", ")", "{", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "<NUM_LIT>", ">", "Outs", ";", "GetReturnInfo", "(", "CC", ",", "F", ".", "getReturnType", "(", ")", ",", "F", ".", "getAttributes", "(", ")", ",", "Outs", ",", "TLI", ",", "DL", ")", ";", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ValLocs", ";", "CCState", "CCInfo", "(", "CC", ",", "F", ".", "isVarArg", "(", ")", ",", "*", "FuncInfo", ".", "MF", ",", "ValLocs", ",", "I", "->", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_X86", ")", ";", "const", "Value", "*", "RV", "=", "Ret", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Register", "Reg", "=", "getRegForValue", "(", "RV", ")", ";", "if", "(", "Reg", "==", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "ValLocs", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "CCValAssign", "&", "VA", "=", "ValLocs", "[", "<NUM_LIT>", "]", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "return", "false", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "return", "false", ";", "if", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "FP1", ")", "return", "false", ";", "unsigned", "SrcReg", "=", "Reg", "+", "VA", ".", "getValNo", "(", ")", ";", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "RV", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "SrcVT", "!=", "DstVT", ")", "{", "if", "(", "SrcVT", "!=", "MVT", "::", "i1", "&&", "SrcVT", "!=", "MVT", "::", "i8", "&&", "SrcVT", "!=", "MVT", "::", "i16", ")", "return", "false", ";", "if", "(", "!", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "&&", "!", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "return", "false", ";", "assert", "(", "DstVT", "==", "MVT", "::", "i32", "&&", "<STR_LIT>", "X86 should always ext to i32", "<STR_LIT>", ")", ";", "if", "(", "SrcVT", "==", "MVT", "::", "i1", ")", "{", "if", "(", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isSExt", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "fastEmitZExtFromI1", "(", "MVT", "::", "i8", ",", "SrcReg", ",", "false", ")", ";", "SrcVT", "=", "MVT", "::", "i8", ";", "}", "unsigned", "Op", "=", "Outs", "[", "<NUM_LIT>", "]", ".", "Flags", ".", "isZExt", "(", ")", "?", "ISD", "::", "ZERO_EXTEND", ":", "ISD", "::", "SIGN_EXTEND", ";", "SrcReg", "=", "fastEmit_r", "(", "SrcVT", ".", "getSimpleVT", "(", ")", ",", "DstVT", ".", "getSimpleVT", "(", ")", ",", "Op", ",", "SrcReg", ",", "false", ")", ";", "}", "Register", "DstReg", "=", "VA", ".", "getLocReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "!", "SrcRC", "->", "contains", "(", "DstReg", ")", ")", "return", "false", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "RetRegs", ".", "push_back", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "}", "if", "(", "F", ".", "hasStructRetAttr", "(", ")", "&&", "CC", "!=", "CallingConv", "::", "Swift", "&&", "CC", "!=", "CallingConv", "::", "SwiftTail", ")", "{", "Register", "Reg", "=", "X86MFInfo", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "<STR_LIT>", "SRetReturnReg should have been set in LowerFormalArguments()!", "<STR_LIT>", ")", ";", "unsigned", "RetReg", "=", "Subtarget", "->", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "RetReg", ")", ".", "addReg", "(", "Reg", ")", ";", "RetRegs", ".", "push_back", "(", "RetReg", ")", ";", "}", "MachineInstrBuilder", "MIB", ";", "if", "(", "X86MFInfo", "->", "getBytesToPopOnReturn", "(", ")" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "UNSPEC_INSN_MOVELIS", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "let", "sz", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "rd", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "rd", ";", "let", "sz", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "int", "mems_ok_for_quad_peep", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "addr1", ",", "addr2", ";", "unsigned", "int", "reg1", ",", "reg2", ";", "int", "offset1", ",", "offset2", ";", "if", "(", "MEM_VOLATILE_P", "(", "mem1", ")", "||", "MEM_VOLATILE_P", "(", "mem2", ")", ")", "return", "<NUM_LIT>", ";", "addr1", "=", "XEXP", "(", "mem1", ",", "<NUM_LIT>", ")", ";", "addr2", "=", "XEXP", "(", "mem2", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "addr1", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", "!=", "REG", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg1", "=", "REGNO", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", ")", "return", "<NUM_LIT>", ";", "offset1", "=", "INTVAL", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addr1", ")", "!=", "REG", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg1", "=", "REGNO", "(", "addr1", ")", ";", "offset1", "=", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "addr2", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", "!=", "REG", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg2", "=", "REGNO", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", ")", "return", "<NUM_LIT>", ";", "offset2", "=", "INTVAL", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addr2", ")", "!=", "REG", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg2", "=", "REGNO", "(", "addr2", ")", ";", "offset2", "=", "<NUM_LIT>", ";", "}", "if", "(", "reg1", "!=", "reg2", ")", "return", "<NUM_LIT>", ";", "if", "(", "offset2", "!=", "offset1", "+", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "addr1", "and", "addr2", "are", "suitable", "for", "lfq", "or", "stfq", "insn", ".", "addr1", "and", "addr2", "must", "be", "in", "consecutive", "memory", "locations", "(", "addr2", "==", "addr1", "+", "8", ")", "." ]

[ "}" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "WebAssembly CFG Sort", "<STR_LIT>", ";" ]

[ "assert", "(", "RegMap", "[", "Stack", "[", "i", "]", "]", "==", "i", "&&", "<STR_LIT>", "Stack[] doesn't match RegMap[]!", "<STR_LIT>", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "StackTop", ";", "++", "i", ")", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", " FP", "<STR_LIT>", "<<", "Stack", "[", "i", "]", ";" ]

[ "V64", ",", "VecListTwo128", ">", ";" ]

[ "def", ":", "SIMDTableLookupAlias", "<", "asm", "#", "<STR_LIT>", ",", "!", "cast", "<", "Instruction", ">", "(", "NAME", "#", "<STR_LIT>", ")", "," ]

[ ")", "{" ]

[ "vreinterpretq_f16_p64", "(", "poly64x2_t", "_", "_", "a" ]

[ "<STR_LIT>", ">", ";" ]

[ "def", "IsMachO", ":", "Predicate", "<" ]