Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "->", "BeginGroup", ")", "{" ]

[ "if", "(", "!", "SC", "->", "isValid", "(", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "SC" ]

[ "_", "b", ")", ";" ]

[ "return", "_", "_", "builtin_arm_uadd16", "(", "_", "_", "a", ",", "_" ]

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

[ "void", "expand_prologue", "(", ")", "{", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ";", "size", "+=", "(", "current_function_outgoing_args_size", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "if", "(", "current_function_varargs", ")", "{", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "<NUM_LIT>", ")", ")", ",", "gen_rtx_REG", "(", "SImode" ]

[ "}" ]

[ "bool", "WDC65816AsmPrinter", "::", "printGetPCX", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "opNum", ",", "raw_ostream", "&", "O", ")", "{", "WDC_LOG", "(", "<STR_LIT>", "WDC_TODO - Unimplemented method called", "<STR_LIT>", ")", ";", "return", "true", ";" ]

[ "MAI", ")", ";" ]

[ "Inst", ".", "dump_pretty", "(", "GetCommentOS", "(", ")", ",", "&", "MAI", ",", "InstPrinter", ".", "get", "(", ")", ",", "<STR_LIT>", "\\n ", "<STR_LIT>", ")", ";", "GetCommentOS", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}", "if", "(", "InstPrinter", ")", "InstPrinter", "->", "printInst", "(", "&", "Inst", ",", "OS", ",", "<STR_LIT>", "<STR_LIT>", ")", ";", "else", "Inst", ".", "print", "(", "OS", ",", "&" ]

[ "let", "cofMax1", "=", "<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>", ";" ]

[ ")", ";" ]

[ "Dst", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "Chain", ",", "Dst", ",", "Src", ",", "DAG", ".", "getConstant", "(", "CopyLen", ",", "dl", ",", "MVT", "::", "i64", ")", ",", "DAG", ".", "getConstant", "(", "Alignment", ".", "value", "(", ")", ",", "dl", ",", "MVT", "::", "i64", ")", ")", ";", "return", "Dst", ".", "getValue", "(", "<NUM_LIT>" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "imm8", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm8", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm8", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "unsigned", "i", "=", "isTwoAddr", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "for", "(", "unsigned", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "<FIXE>" ]

[ "REX", "|=", "<NUM_LIT>", "<<", "<NUM_LIT>", ";", "if", "(", "MI", ".", "getNumOperands", "(", ")", ")", "{", "bool", "isTrunc8", "=", "isX86_64TruncToByte", "(", "Opcode", ")", ";", "<BUGS>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "<BUGE>", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegister", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";" ]

[ "BA", ",", "getPointerTy", "(", "DL", ")", ")", ";" ]

[ "const", "BlockAddress", "*", "BA", "=", "cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", "->", "getBlockAddress", "(", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getTargetBlockAddress", "(" ]

[ "}" ]

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

[ "MVT", "::", "i32", ")", ",", "LHS", ",", "RHS", ",", "TrueValue", ",", "FalseValue", ")", ";" ]

[ "EVT", "TrueType", "=", "TrueValue", ".", "getValueType", "(", ")", ";", "EVT", "FalseType", "=", "FalseValue", ".", "getValueType", "(", ")", ";", "if", "(", "TrueType", "!=", "FalseType", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "mismatched types of select_cc true and false nodes", "<STR_LIT>", ")", ";", "}", "SDValue", "SelectMove", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "TrueType", ",", "DAG", ".", "getConstant", "(", "CC", ",", "DL", "," ]

[ "R", ")", ";" ]

[ "extern", "_", "_", "inline", "unsigned", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvt_roundsd_u32", "(", "_", "_", "m128d", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "unsigned", ")", "_", "_", "builtin_ia32_vcvtsd2usi32", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "_", "_" ]

[ ")", "value", ";" ]

[ "void", "printU5ImmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ")", "{", "unsigned", "char", "value", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ";", "assert", "(", "value", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid u5imm argument!", "<STR_LIT>", ")", ";", "O", "<<", "(", "unsigned", "int" ]

[ "SchedRW", ";" ]

[ "let", "SOPC", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";", "let", "SubtargetPredicate", "=", "ps", ".", "SubtargetPredicate", ";", "let", "OtherPredicates", "=", "ps", ".", "OtherPredicates", ";", "let", "AsmMatchConverter", "=", "ps", ".", "AsmMatchConverter", ";", "let", "UseNamedOperandTable", "=", "ps", ".", "UseNamedOperandTable", ";", "let", "TSFlags", "=", "ps", ".", "TSFlags", ";", "let", "SchedRW", "=", "ps", "." ]

[ "miI", "!=", "miE", ";", "++", "miI", ")", "{" ]

[ "static", "bool", "isEFLAGSLiveAfter", "(", "MachineBasicBlock", "::", "iterator", "Itr", ",", "MachineBasicBlock", "*", "BB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "miI", "=", "std", "::", "next", "(", "Itr", ")", ",", "miE", "=", "BB", "->", "end", "(", ")", ";" ]

[ "return", ";" ]

[ "SmallString", "<", "<NUM_LIT>", ">", "TmpStr", ";", "raw_svector_ostream", "OS", "(", "TmpStr", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "OS", ".", "str", "(", ")", ")", ")", ";", "}" ]

[ "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "M0", "&&", "<STR_LIT>", "m0 should not be spilled", "<STR_LIT>", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC", "&&", "<STR_LIT>", "exec should not be spilled", "<STR_LIT>", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "SrcReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "<NUM_LIT>", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ ",", "End", ",", "Size", ")", ";" ]

[ "const", "MCExpr", "*", "Disp", "=", "MCConstantExpr", "::", "Create", "(", "ImmDisp", ",", "getContext", "(", ")", ")", ";", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "SegReg", ",", "Disp", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "Start", ",", "ImmDispToken", ".", "getEndLoc", "(", ")", ",", "Size", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "return", "ParseIntelBracExpression", "(", "SegReg", ",", "Start", ",", "ImmDisp", ",", "Size", ")", ";", "const", "MCExpr", "*", "Val", ";", "SMLoc", "End", ";", "if", "(", "!", "isParsingInlineAsm", "(", ")", ")", "{", "if", "(", "getParser", "(", ")", ".", "parsePrimaryExpr", "(", "Val", ",", "End", ")", ")", "return", "ErrorOperand", "(", "Tok", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "unknown token in expression", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "::", "<STR_LIT>", "(", "Val", ",", "Start" ]

[ ")", ")", "]", ")" ]

[ "(", "define_split", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "SI", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "if_then_else", ":", "SI", "(", "ne", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

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

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

[ "}" ]

[ "class", "BaseSIMDMov", "<", "bit", "Q", ",", "string", "size", ",", "bits", "<", "<NUM_LIT>", ">", "imm4", ",", "RegisterClass", "regtype", ",", "Operand", "idxtype", ",", "string", "asm", ",", "list", "<", "dag", ">", "pattern", ">", ":", "BaseSIMDInsDup", "<", "Q", ",", "<NUM_LIT>", ",", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "V128", ":", "$", "Rn", ",", "idxtype", ":", "$", "idx", ")", ",", "asm", ",", "<STR_LIT>", "#", "size", "#", "<STR_LIT>", "#", "<STR_LIT>", "#", "size", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm4", ";" ]

[ "bool", "XCoreAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "if", "(", "!", "FileDirective", ".", "empty", "(", ")", ")", "{", "emitFileDirective", "(", "FileDirective", ")", ";", "}", "for", "(", "Module", "::", "const_iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isDeclaration", "(", ")", "&&", "!", "I", "->", "isIntrinsic", "(", ")", ")", "{", "switch", "(", "I", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected linkage", "<STR_LIT>", ")", ";", "case", "Function", "::", "ExternalWeakLinkage", ":", "ExtWeakSymbols", ".", "insert", "(", "I", ")", ";", "case", "Function", "::", "ExternalLinkage", ":", "break", ";", "}", "}", "}", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "assert", "(", "DW", "&&", "<STR_LIT>", "Dwarf Writer is not available", "<STR_LIT>", ")", ";", "DW", "->", "BeginModule", "(", "&", "M", ",", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ",", "O", ",", "this", ",", "TAI", ")", ";", "return", "Result", ";", "}" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "<FIXS>", "emit_move_insn", "(", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "SFmode", ")", ",", "operand_subword_force", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "SFmode", ")", ")", "<FIXE>" ]

[ "if", "(", "result", "!", "=", "target", ")", "emit_move_insn", "(", "result", ",", "target", ")", "<BUGS>", "emit_move_insn", "(", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "SFmode", ")", ",", "operand_subword_force", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "SFmode", ")", ")", "<BUGE>", "insns", "=", "get_insns", "(", ")", "end_sequence", "(", ")" ]

[ "P", ",", "_", "_", "m512i", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_store_epi64", "(", "void", "*", "_", "_" ]

[ "<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", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=" ]

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

[ "def", "A2_orir", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_140c83", ",", "ImmRegRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "Prefix", ".", "setBB2", "(", "MI", ",", "CurOp", ")", ";", "<FIXE>" ]

[ "if", "(", "HasEVEX_K", ")", "Prefix", ".", "setAAA", "(", "MI", ",", "CurOp", "++", ")", ";", "<BUGS>", "Prefix", ".", "setB", "(", "MI", ",", "CurOp", ")", ";", "<BUGE>", "Prefix", ".", "setX", "(", "MI", ",", "CurOp", ",", "<NUM_LIT>", ")", ";", "break", ";" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "}" ]

[ "EncodedValue", "|=", "<NUM_LIT>", "<<", "<NUM_LIT>", ";", "return", "EncodedValue", ";" ]

[ "<FIXS>", "if", "(", "VerboseAsm", ")", "<FIXE>" ]

[ "processDebugLoc", "(", "MI", ",", "true", ")", ";", "printInstruction", "(", "MI", ")", ";", "<BUGS>", "if", "(", "VerboseAsm", "&&", "!", "MI", "->", "getDebugLoc", "(", ")", ".", "isUnknown", "(", ")", ")", "<BUGE>", "EmitComments", "(", "*", "MI", ")", ";", "processDebugLoc", "(", "MI", ",", "false", ")", ";", "O", "<<", "'", "\\n", "'", ";" ]

[ "<FIXS>", "{", "<NUM_LIT>", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "<FIXE>" ]

[ "{", "<NUM_LIT>", ",", "MVT", "::", "v2i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v4i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v8i8", ",", "<NUM_LIT>", "}", ",", "<BUGS>", "{", "<NUM_LIT>", ",", "MVT", "::", "v16i8", ",", "<NUM_LIT>", "}", ",", "<BUGE>", "{", "<NUM_LIT>", ",", "MVT", "::", "v32i8", ",", "<NUM_LIT>", "}", ",", "{", "<NUM_LIT>", ",", "MVT", "::", "v2i16", ",", "<NUM_LIT>", "}", "," ]

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

[ "def", "A2_andp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_946df596", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "return", "isPPC64", "(", ")", "?", "<STR_LIT>", "E-p:64:64-f64:64:64-i64:64:64-f128:64:128-n32:64", "<STR_LIT>", ":", "<STR_LIT>", "E-p:32:32-f64:64:64-i64:64:64-f128:64:128-n32", "<STR_LIT>", ";" ]

[ "if", "(", "isPPC64", "(", ")", "&&", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "TargetTriple", ".", "getOS", "(", ")", "==", "llvm", "::", "Triple", "::", "FreeBSD", ")", "return", "<STR_LIT>", "E-p:64:64-f64:64:64-i64:64:64-f128:64:64-v128:128:128-n32:64", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "E-p:64:64-f64:64:64-i64:64:64-f128:128:128-v128:128:128-n32:64", "<STR_LIT>", ";", "}" ]

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

[ "def", "HasSPE", ":", "Predicate", "<", "<STR_LIT>", ">", "," ]

[ "}" ]

[ "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "return", "Hexagon", "::", "R30", ";", "}", "return", "Hexagon", "::", "R29", ";" ]

[ "let", "ParserMatchClass", "=", "RhazRsAsmOperand", ";" ]

[ "def", "RhazRsOp", ":", "Operand", "<", "i8", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

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

[ "if", "(", "isTargetCOFF", "(", ")", ")", "{", "assert", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", "&&", "<STR_LIT>", "shouldAssumeDSOLocal gave inconsistent answer", "<STR_LIT>", ")", ";", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "const", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "{", "if", "(", "is64Bit", "(", ")", "&&", "F", "&&", "(", "CallingConv", "::", "X86_RegCall", "==", "F", "->", "getCallingConv", "(", ")", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", "&&", "is64Bit", "(", ")", ")", "return", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

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

[ "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "TF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "DomTree", "->", "eraseNode", "(", "RemovedMBB", ")", ";" ]

[ "assert", "(", "Node", "->", "getIDom", "(", ")", "==", "HeadNode", "&&", "<STR_LIT>", "CmpBB should be dominated by Head", "<STR_LIT>", ")", ";", "while", "(", "Node", "->", "getNumChildren", "(", ")", ")", "DomTree", "->", "changeImmediateDominator", "(", "Node", "->", "getChildren", "(", ")", ".", "back", "(", ")", ",", "HeadNode", ")", ";" ]

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

[ "def", "SDT_CheriBoolBinary", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisInt", "<", "<NUM_LIT>", ">", ",", "SDTCisVT", "<", "<NUM_LIT>", ",", "CapRegType", ">", ",", "SDTCisVT" ]

[ ">", ";" ]

[ "def", "fixedpoint_f32_i64", ":", "fixedpoint_i64", "<", "f32" ]

[ "<STR_LIT>" ]

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

[ "llvm_unreachable", "(", "<STR_LIT>", "Should never be called!", "<STR_LIT>", ")", ";" ]

[ "static", "Value", "*", "convertTo16Bit", "(", "Value", "&", "V", ",", "InstCombiner", "::", "BuilderTy", "&", "Builder", ")", "{", "Type", "*", "VTy", "=", "V", ".", "getType", "(", ")", ";", "if", "(", "isa", "<", "FPExtInst", ">", "(", "&", "V", ")", "||", "isa", "<", "SExtInst", ">", "(", "&", "V", ")", "||", "isa", "<", "ZExtInst", ">", "(", "&", "V", ")", ")", "return", "cast", "<", "Instruction", ">", "(", "&", "V", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "VTy", "->", "isIntegerTy", "(", ")", ")", "return", "Builder", ".", "CreateIntCast", "(", "&", "V", ",", "Type", "::", "getInt16Ty", "(", "V", ".", "getContext", "(", ")", ")", ",", "false", ")", ";", "if", "(", "VTy", "->", "isFloatingPointTy", "(", ")", ")", "return", "Builder", ".", "CreateFPCast", "(", "&", "V", ",", "Type", "::", "getHalfTy", "(", "V", ".", "getContext", "(", ")", ")", ")", ";" ]

[ "No support for huge argument lists yet", "<STR_LIT>", ")", ";" ]

[ "uint64_t", "Offset", "=", "(", "MFFrame", ".", "getMaxCallFrameSize", "(", ")", "+", "Regs", "->", "getCallFrameSize", "(", ")", "+", "Regs", "->", "getStackPointerBias", "(", ")", "+", "OffsetMO", ".", "getImm", "(", ")", ")", ";", "unsigned", "NewOpcode", "=", "getOpcodeForOffset", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "<STR_LIT>" ]

[ "}" ]

[ "SDValue", "In", "=", "Op", ".", "getOperand", "(", "idx", ")", ";", "if", "(", "In", ".", "isUndef", "(", ")", ")", "continue", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "In", ")", ")", "NonConstIdx", ".", "push_back", "(", "idx", ")", ";", "else", "{", "Immediate", "|=", "(", "cast", "<", "ConstantSDNode", ">", "(", "In", ")", "->", "getZExtValue", "(", ")", "&", "<NUM_LIT>", ")", "<<", "idx", ";", "HasConstElts", "=", "true", ";", "}", "if", "(", "SplatIdx", "<", "<NUM_LIT>", ")", "SplatIdx", "=", "idx", ";", "else", "if", "(", "In", "!=", "Op", ".", "getOperand", "(", "SplatIdx", ")", ")", "IsSplat", "=", "false", ";", "}", "if", "(", "IsSplat", ")", "{", "SDValue", "Cond", "=", "Op", ".", "getOperand", "(", "SplatIdx", ")", ";", "assert", "(", "Cond", ".", "getValueType", "(", ")", "==", "MVT", "::", "i8", "&&", "<STR_LIT>", "Unexpected VT!", "<STR_LIT>", ")", ";", "if", "(", "Cond", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SETCC", ")", "Cond", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i8", ",", "Cond", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i8", ")", ")", ";", "return", "DAG", ".", "getSelect", "(", "dl", ",", "VT", ",", "Cond", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "VT", ")", ")", ";" ]

[ "B", ",", "(", "_", "_", "v2df", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_div_round_sd", "(", "_", "_", "m128d", "_", "_", "W", ",", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_divsd_mask_round", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "(", "_", "_", "v2df", ")", "_", "_" ]

[ "}" ]

[ "def", "KryoWrite_3cyc_LS_LS_noRSV_noRSV_noRSV_noRSV_358ln", ":", "SchedWriteRes", "<", "[", "KryoUnitLS", ",", "KryoUnitLS", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "case", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_HI16", ":" ]

[ "case", "Mips", "::", "fixup_Mips_GPOFF_HI", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_HI16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_GPOFF_LO", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_LO16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_HIGHER", ":", "return", "ELF", "::", "R_MIPS_HIGHER", ";", "case", "Mips", "::", "fixup_Mips_HIGHEST", ":", "return", "ELF", "::", "R_MIPS_HIGHEST", ";", "case", "Mips", "::", "fixup_Mips_SUB", ":", "return", "ELF", "::", "R_MIPS_SUB", ";", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "return", "ELF", "::", "R_MIPS_GOT_HI16", ";", "case", "Mips", "::", "fixup_Mips_GOT_LO16", ":", "return", "ELF", "::", "R_MIPS_GOT_LO16", ";", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "return", "ELF", "::", "R_MIPS_CALL_HI16", ";", "case", "Mips", "::", "fixup_Mips_CALL_LO16", ":", "return", "ELF", "::", "R_MIPS_CALL_LO16", ";", "case", "Mips", "::", "fixup_MICROMIPS_26_S1", ":", "return", "ELF", "::", "R_MICROMIPS_26_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_HI16", ":", "return", "ELF", "::", "R_MICROMIPS_HI16", ";", "case", "Mips", "::", "fixup_MICROMIPS_LO16", ":", "return", "ELF", "::", "R_MICROMIPS_LO16", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT16", ":", "return", "ELF", "::", "R_MICROMIPS_GOT16", ";", "case", "Mips", "::", "fixup_MICROMIPS_CALL16", ":", "return", "ELF", "::", "R_MICROMIPS_CALL16", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_DISP", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_PAGE", ";", "case", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ":", "return", "ELF", "::", "R_MICROMIPS_GOT_OFST", ";", "case", "Mips", "::", "fixup_MICROMIPS_TLS_GD", ":", "return", "ELF", "::", "R_MICROMIPS_TLS_GD", ";", "case", "Mips", "::", "fixup_MICROMIPS_TLS_LDM", ":", "return", "ELF", "::", "R_MICROMIPS_TLS_LDM", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "CS", "]", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ ";" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "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", "=", "<NUM_LIT>" ]

[ ")", ";" ]

[ "bool", "HexagonBitSimplify", "::", "isTransparentCopy", "(", "const", "BitTracker", "::", "RegisterRef", "&", "RD", ",", "const", "BitTracker", "::", "RegisterRef", "&", "RS", ",", "MachineRegisterInfo", "&", "MRI", ")", "{", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "RD", ".", "Reg", ")", "||", "!", "Register", "::", "isVirtualRegister", "(", "RS", ".", "Reg", ")", ")", "return", "false", ";", "auto", "*", "DRC", "=", "getFinalVRegClass", "(", "RD", ",", "MRI" ]

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

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ ")", "{" ]

[ "signed", "getJTI", "(" ]

[ "void", "rs6000_set_handled_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "gpr_is_wrapped_separately", "[", "i", "]", "=", "true", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "cfun", "->", "machine", "->", "fpr_is_wrapped_separately", "[", "i", "-", "<NUM_LIT>", "]", "=", "true", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "<NUM_LIT>", ")", ")", "cfun", "->", "machine", "->", "lr_is_wrapped_separately", "=", "true", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "<NUM_LIT>", ")", ")", "cfun", "->", "machine", "->", "toc_is_wrapped_separately", "=", "true", ";", "}" ]

[ "Implement", "TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS", "." ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "zero_extend", ":", "SI", "(", "mem", ":", "HI", "(", "plus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

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

[ "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "==", "<NUM_LIT>", ")", "return", ";" ]

[ "MCInst", "MCB", ";", "MCB", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MCB", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "const", "MCInstrInfo", "&", "MCII", "=", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "assert", "(", "Subtarget", "->", "usePackets", "(", ")", "&&", "<STR_LIT>", "Support for packets is disabled", "<STR_LIT>", ")", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "for", "(", "++", "MII", ";", "MII", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ";", "++", "MII", ")", "if", "(", "!", "MII", "->", "isDebugValue", "(", ")", "&&", "!", "MII", "->", "isImplicitDef", "(", ")", ")", "HexagonLowerToMC", "(", "MCII", ",", "&", "*", "MII", ",", "MCB", ",", "*", "this", ")", ";", "}", "else", "HexagonLowerToMC", "(", "MCII", ",", "MI", ",", "MCB", ",", "*", "this", ")", ";", "bool", "Ok", "=", "HexagonMCInstrInfo", "::", "canonicalizePacket", "(", "MCII", ",", "*", "Subtarget", ",", "OutStreamer", "->", "getContext", "(", ")", ",", "MCB", ",", "nullptr", ")", ";", "assert", "(", "Ok", ")", ";", "(", "void", ")", "Ok", ";" ]

[ "if", "(", "!", "isFunctionGlobalAddress", "(", "Callee", ")", "&&", "!", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "return", "false", ";" ]

[ "CallingConv", "::", "ID", "CallerCC", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "if", "(", "CallerCC", "!=", "CalleeCC", ")", "return", "false", ";", "if", "(", "CalleeCC", "!=", "CallingConv", "::", "Fast", "&&", "CalleeCC", "!=", "CallingConv", "::", "C", ")", "return", "false", ";", "if", "(", "any_of", "(", "Ins", ",", "[", "]", "(", "const", "ISD", "::", "InputArg", "&", "IA", ")", "{", "return", "IA", ".", "Flags", ".", "isByVal", "(", ")", ";", "}", ")", ")", "return", "false", ";", "if", "(", "any_of", "(", "Outs", ",", "[", "]", "(", "const", "ISD", "::", "OutputArg", "&", "OA", ")", "{", "return", "OA", ".", "Flags", ".", "isByVal", "(", ")", ";", "}", ")", ")", "return", "false", ";" ]

[ "(", "prefix", "#", "<STR_LIT>", ")", "VPR128", ":", "$", "Rn", ",", "imm", ":", "$", "Imm", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v2i32", "(", "op", "(", "v2i64", "VPR128", ":", "$", "Rn", ")", ",", "shr_imm32", ":", "$", "Imm", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">" ]

[ ")" ]

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

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

[ "assert", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "==", "RC", ")", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "<NUM_LIT>", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "NumInsts", "<=", "<NUM_LIT>", ";", "}", "case", "SCC_TRUE", ":", "case", "SCC_FALSE", ":", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ";", "assert", "(", "MRI", ".", "getRegClass", "(", "FalseReg", ")", "==", "RC", ")", ";", "int", "NumInsts", "=", "AMDGPU", "::", "getRegBitWidth", "(", "RC", "->", "getID", "(", ")", ")", "/", "<NUM_LIT>", ";", "if", "(", "NumInsts", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "NumInsts", "/", "=", "<NUM_LIT>", ";", "CondCycles", "=", "TrueCycles", "=", "FalseCycles", "=", "NumInsts", ";", "return", "RI", ".", "isSGPRClass", "(", "RC", ")", ";", "}", "default", ":" ]

[ "}" ]

[ "bool", "HasPrealloc", "=", "const_cast", "<", "MachineFrameInfo", "&", ">", "(", "MFI", ")", ".", "getLocalFrameObjectCount", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "true", ";", "if", "(", "(", "HasFixed", "||", "HasPrealloc", ")", "&&", "(", "HasAlloca", "||", "HasExtraAlign", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", ">", "<NUM_LIT>", ")", "{", "if", "(", "EnableStackOVFSanitizer", "||", "UseAllocframe", ")", "return", "true", ";", "}", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasClobberLR", "(", ")", ")", "return", "true", ";", "return", "false", ";" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "i32imm", ",", "i32imm", ")", ";" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "AddSubImmOperand", ";" ]

[ "mmask16", "_", "_", "U", ",", "_", "_", "m512i", "_", "_", "X", ",", "_", "_", "m512i", "_", "_", "Y", ",", "const", "int", "_", "_", "P", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask16", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cmp_epu32_mask", "(", "_", "_" ]

[ ";" ]

[ "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "<NUM_LIT>", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "arg", ".", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment" ]

[ "_", "v4di", ")", "_", "_", "Z", ")", ";" ]

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_vpmadd52luq256", "(", "(", "_", "_", "v4di", ")", "_", "_", "X", ",", "(", "_", "_", "v4di", ")", "_", "_", "Y", ",", "(", "_" ]

[ "UNSPECV_BLOCKAGE", ")", "]" ]

[ "[", "(", "unspec_volatile", "[", "(", "const_int", "<NUM_LIT>", ")", "]" ]

[ "return", "Size", ";" ]

[ "assert", "(", "!", "I", "->", "isBundle", "(", ")", "&&", "<STR_LIT>", "No nested bundle!", "<STR_LIT>", ")", ";", "Size", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "}" ]

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

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

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

[ "def", "A2_psubfnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_05c070ec", ",", "TypeALU32_3op", ">", ",", "Enc_9b0bc1", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "<STR_LIT>", ")" ]

[ "(", "define_cpu_unit", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "~", "Imm64", ")", ";" ]

[ "if", "(", "Val", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ANY_EXTEND", ")", "{", "auto", "Op0", "=", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "isInt32Immediate", "(", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "Imm", ")", "&&", "Imm", "<=", "MB", ")", "{", "auto", "ResultType", "=", "Val", ".", "getNode", "(", ")", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "auto", "ImDef", "=", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "IMPLICIT_DEF", ",", "dl", ",", "ResultType", ")", ";", "SDValue", "IDVal", "(", "ImDef", ",", "<NUM_LIT>", ")", ";", "Val", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "PPC", "::", "INSERT_SUBREG", ",", "dl", ",", "ResultType", ",", "IDVal", ",", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "getI32Imm", "(", "<NUM_LIT>", ",", "dl", ")", ")", ",", "<NUM_LIT>", ")", ";", "SH", "=", "<NUM_LIT>", "-", "Imm", ";", "}", "}", "if", "(", "Val", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SRL", "&&", "isInt32Immediate", "(", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "Imm", ")", "&&", "Imm", "<=", "MB", ")", "{", "assert", "(", "Imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "Illegal shift amount", "<STR_LIT>", ")", ";", "Val", "=", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SH", "=", "<NUM_LIT>", "-", "Imm", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Val", ",", "getI32Imm", "(", "SH", ",", "dl", ")", ",", "getI32Imm", "(", "MB", ",", "dl", ")", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "PPC", "::", "RLDICL", ",", "MVT", "::", "i64", ",", "Ops", ")", ";", "return", "true", ";", "}", "else", "if", "(", "isMask_64", "(", "~", "Imm64", ")", ")", "{", "MB", "=", "<NUM_LIT>", "-", "countTrailingOnes", "(" ]

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

[ "(", "shiftrt", ":", "BW", "(", "match_operand", ":", "BW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "BW", "<NUM_LIT>" ]

[ "V16QI", "]", ")" ]

[ "(", "define_mode_iterator", "VIshort", "[", "V8HI" ]

[ "assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "<NUM_LIT>", ")", ";" ]

[ "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ ")", ",", "(", "f32", "(", "opnode", "(", "v4f32", "VPR128", ":", "$", "Rn", ")", ")", ")", ")", "]", ",", "NoItinerary", ">", ";" ]

[ "def", "_1s4s", ":", "NeonI_2VAcross", "<", "<NUM_LIT>", ",", "u", ",", "size", ",", "opcode", ",", "(", "outs", "FPR32", ":", "$", "Rd", ")", ",", "(", "ins", "VPR128", ":", "$", "Rn", ")", ",", "asmop", "#", "<STR_LIT>", ",", "[", "(", "set", "(", "f32", "FPR32", ":", "$", "Rd" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V8QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_concat", ":", "V8QI", "(", "us_truncate", ":", "V4QI", "(", "match_operand", ":", "V4HI", "<NUM_LIT>" ]

[ "}" ]

[ "vec_int4", "exp", ";", "vec_float4", "frac", ";", "exp", "=", "spu_add", "(", "(", "vec_int4", ")", "(", "spu_and", "(", "spu_rlmask", "(", "(", "vec_uint4", ")", "(", "a", ")", ",", "-", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ",", "-", "<NUM_LIT>", ")", ";", "frac", "=", "(", "vec_float4", ")", "(", "spu_sub", "(", "(", "vec_int4", ")", "(", "a", ")", ",", "spu_sl", "(", "exp", ",", "<NUM_LIT>", ")", ")", ")", ";", "return", "(", "spu_madd", "(", "spu_madd", "(", "spu_splats", "(", "-", "<NUM_LIT>", ")", ",", "frac", ",", "spu_splats", "(", "<NUM_LIT>", ")", ")", ",", "frac", ",", "spu_sub", "(", "spu_convtf", "(", "exp", ",", "<NUM_LIT>", ")", ",", "spu_splats", "(", "<NUM_LIT>", ")", ")", ")", ")", ";" ]

[ "return", "general_operand", "(", "op", ",", "mode", ")" ]

[ "(", "match_code", "<STR_LIT>", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "=", "=", "mode", "&", "&", "GET_CODE", "(", "op", ")", "=", "=", "MEM", "&", "&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "=", "=", "POST_INC", ")", "return", "<NUM_LIT>" ]

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

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

[ "(", ")", ",", "FullDestReg", ")", ";" ]

[ "MachineBasicBlock", "&", "MBB", "=", "*", "Inst", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineOperand", "&", "Dest", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "Src0", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "DL", "=", "Inst", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "Inst", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "get", "(", "Opcode", ")", ";", "const", "TargetRegisterClass", "*", "Src0RC", "=", "Src0", ".", "isReg", "(", ")", "?", "MRI", ".", "getRegClass", "(", "Src0", ".", "getReg", "(", ")", ")", ":", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "const", "TargetRegisterClass", "*", "Src0SubRC", "=", "RI", ".", "getSubRegClass", "(", "Src0RC", ",", "AMDGPU", "::", "sub0", ")", ";", "MachineOperand", "SrcReg0Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub0", ",", "Src0SubRC", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "Dest", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "NewDestRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "DestRC", ")", ";", "const", "TargetRegisterClass", "*", "NewDestSubRC", "=", "RI", ".", "getSubRegClass", "(", "NewDestRC", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestSubRC", ")", ";", "MachineInstr", "&", "LoHalf", "=", "*", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub0", ")", ".", "add", "(", "SrcReg0Sub0", ")", ";", "MachineOperand", "SrcReg0Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub1", ",", "Src0SubRC", ")", ";", "unsigned", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestSubRC", ")", ";", "MachineInstr", "&", "HiHalf", "=", "*", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub1", ")", ".", "add", "(", "SrcReg0Sub1", ")", ";", "unsigned", "FullDestReg", "=", "MRI", ".", "createVirtualRegister", "(", "NewDestRC", ")", ";", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "FullDestReg", ")", ".", "addReg", "(", "DestSub0", ")", ".", "addImm", "(", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "DestSub1", ")", ".", "addImm", "(", "AMDGPU", "::", "sub1", ")", ";", "MRI", ".", "replaceRegWith", "(", "Dest", ".", "getReg" ]

[ ";" ]

[ "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", "&&", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "String", ")", ")", "return", "Error", "(", "L", ",", "<STR_LIT>", "unexpected token in directive", "<STR_LIT>", ")", ";", "StringRef", "CPU", "=", "Parser", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "Parser", ".", "Lex", "(", ")" ]

[ ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "rotate", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "(", "MF", ")", ")", "return", "true", ";" ]

[ "unsigned", "FP", "=", "Subtarget", ".", "isGP32bit", "(", ")", "?", "Mips", "::", "FP", ":", "Mips", "::", "FP_64", ";", "unsigned", "BP", "=", "Subtarget", ".", "isGP32bit", "(", ")", "?", "Mips", "::", "S7", ":", "Mips", "::", "S7_64", ";", "if", "(", "!", "Subtarget", ".", "hasStandardEncoding", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "canReserveReg", "(", "FP", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame" ]

[ "MVT", "::", "f64", ")", "{" ]

[ "SDValue", "SystemZTargetLowering", "::", "combineFP_EXTEND", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "f64", "&&", "Op0", ".", "hasOneUse", "(", ")", "&&", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "v4f32", "&&", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "cast", "<", "ConstantSDNode", ">", "(", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "Vec", "=", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "for", "(", "auto", "*", "U", ":", "Vec", "->", "uses", "(", ")", ")", "{", "if", "(", "U", "!=", "Op0", ".", "getNode", "(", ")", "&&", "U", "->", "hasOneUse", "(", ")", "&&", "U", "->", "getOpcode", "(", ")", "==", "ISD", "::", "EXTRACT_VECTOR_ELT", "&&", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", "==", "Vec", "&&", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "&&", "cast", "<", "ConstantSDNode", ">", "(", "U", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "OtherExtend", "=", "SDValue", "(", "*", "U", "->", "use_begin", "(", ")", ",", "<NUM_LIT>", ")", ";", "if", "(", "OtherExtend", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", "&&", "OtherExtend", ".", "getOperand", "(", "<NUM_LIT>", ")", "==", "SDValue", "(", "U", ",", "<NUM_LIT>", ")", "&&", "OtherExtend", ".", "getValueType", "(", ")", "==" ]

[ "_", "v8qi", ")", "_", "_", "B", ")", ";" ]

[ "return", "(", "_", "_", "m64", ")", "_", "_", "builtin_ia32_pmaxub", "(", "(", "_", "_", "v8qi", ")", "_", "_", "A", ",", "(", "_" ]

[ "unsigned", "stkSze", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";" ]

[ "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stkReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "retReg", "=", "RI", ".", "getRARegister", "(", ")", ";" ]

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

[ "def", ":", "Pat", "<", "(", "v2f64", "(", "ftrunc", "VR128", ":", "$", "src", ")", ")", ",", "(", "ROUNDPDr", "VR128", ":", "$", "src", "," ]

[ "<FIXS>", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ";", "<FIXE>" ]

[ "intint5_operand", "(", "op", ",", "mode", ")", "rtx", "op", ";", "<BUGS>", "enum", "machine_mode", "mode", ";", "<BUGE>", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INT_5_BITS", "(", "op", ")", ")", ";", "}" ]

[ "if", "(", "optimize_size", ")", "return", "<NUM_LIT>", ";" ]

[ "static", "inline", "int", "multcosts", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "sh_multcost", ">=", "<NUM_LIT>", ")", "return", "sh_multcost", ";", "if", "(", "TARGET_SHMEDIA", ")", "return", "optimize_size", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "if", "(", "TARGET_SH2", ")", "{", "if", "(", "optimize_size", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extract", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]