Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "(", "Op0", ")", ")", "{" ]

[ "WhichConst", "=", "Const", "->", "isNegative", "(", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "else", "if", "(", "Const", "->", "isExactlyValue", "(", "Smallest", ")", ")", "{", "if", "(", "(", "Pred", "&", "CmpInst", "::", "FCMP_OGE", ")", "!=", "CmpInst", "::", "FCMP_OGE", "&&", "(", "Pred", "&", "CmpInst", "::", "FCMP_OGE", ")", "!=", "<NUM_LIT>", ")", "return", ";", "WhichConst", "=", "<NUM_LIT>", ";", "}", "else", "if", "(", "Const", "->", "isExactlyValue", "(", "NegSmallest", ")", ")", "{", "if", "(", "(", "Pred", "&", "CmpInst", "::", "FCMP_OLE", ")", "!=", "CmpInst", "::", "FCMP_OLE", "&&", "(", "Pred", "&", "CmpInst", "::", "FCMP_OLE", ")", "!=", "<NUM_LIT>", ")", "return", ";", "WhichConst", "=", "<NUM_LIT>", ";", "}", "else", "{", "return", ";", "}", "static", "const", "int", "Masks", "[", "]", "[", "<NUM_LIT>", "]", "=", "{", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "}", ",", "{", "<NUM_LIT>", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "}", ",", "{", "<NUM_LIT>", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "}", "}", ";", "int", "Mask", "=", "<NUM_LIT>", ";", "if", "(", "Pred", "&", "CmpInst", "::", "FCMP_OEQ", ")", "Mask", "|=", "Masks", "[", "WhichConst", "]", "[", "<NUM_LIT>", "]", ";", "if", "(", "Pred", "&", "CmpInst", "::", "FCMP_OGT", ")", "Mask", "|=", "Masks", "[", "WhichConst", "]", "[", "<NUM_LIT>", "]", ";", "if", "(", "Pred", "&", "CmpInst", "::", "FCMP_OLT", ")", "Mask", "|=", "Masks", "[", "WhichConst", "]", "[", "<NUM_LIT>", "]", ";", "if", "(", "Pred", "&", "CmpInst", "::", "FCMP_UNO", ")", "Mask", "|=", "Masks", "[", "WhichConst", "]", "[", "<NUM_LIT>", "]", ";", "bool", "Worthy", "=", "false", ";", "if", "(", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">" ]

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

[ "unsigned", "AddrIdx", ";", "if", "(", "(", "isBasePlusOffsetMemoryAccess", "(", "CurrI", "->", "getOpcode", "(", ")", ",", "&", "AddrIdx", ")", "&&", "baseRegNeedsLoadStoreMask", "(", "CurrI", "->", "getOperand", "(", "AddrIdx", ")", ".", "getReg", "(", ")", ")", ")", "||", "CurrI", "->", "modifiesRegister", "(", "Mips", "::", "SP", ",", "STI", ".", "getRegisterInfo", "(", ")", ")", ")", "continue", ";", "}", "bool", "InMicroMipsMode", "=", "STI", ".", "inMicroMipsMode", "(", ")", ";", "const", "MipsInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "unsigned", "Opcode", "=", "(", "*", "Slot", ")", ".", "getOpcode", "(", ")", ";", "if", "(", "InMicroMipsMode", "&&", "TII", "->", "getInstSizeInBytes", "(", "*", "CurrI", ")", "==", "<NUM_LIT>", "&&", "(", "Opcode", "==", "Mips", "::", "JR", "||", "Opcode", "==", "Mips", "::", "PseudoIndirectBranch", "||", "Opcode", "==", "Mips", "::", "PseudoReturn", "||", "Opcode", "==", "Mips", "::", "TAILCALL", ")", ")", "continue", ";", "Filler", "=", "CurrI", ";" ]

[ "let", "ElementSize", "=", "ElementSizeNone", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz8_64", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zdn", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DestructiveInstType", "=", "Destructive", ";" ]

[ "else", "llvm_unreachable", "(", "<STR_LIT>", "Cannot store this register to stack slot!", "<STR_LIT>", ")", ";" ]

[ "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";" ]

[ ")", "const", "override", "{" ]

[ "StringRef", "getPassName", "(" ]

[ "DAG", ".", "ReplaceAllUsesWith", "(", "BR", ",", "NewBR", ".", "getNode", "(", ")", ")", ";" ]

[ "SDLoc", "DL", "(", "BRCOND", ")", ";", "SDNode", "*", "Intr", "=", "BRCOND", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "SDValue", "Target", "=", "BRCOND", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDNode", "*", "BR", "=", "nullptr", ";", "SDNode", "*", "SetCC", "=", "nullptr", ";", "if", "(", "Intr", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SETCC", ")", "{", "SetCC", "=", "Intr", ";", "Intr", "=", "SetCC", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "}", "else", "{", "BR", "=", "findUser", "(", "BRCOND", ",", "ISD", "::", "BR", ")", ";", "Target", "=", "BR", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "isCFIntrinsic", "(", "Intr", ")", ")", "{", "return", "BRCOND", ";", "}", "assert", "(", "!", "SetCC", "||", "(", "SetCC", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "cast", "<", "CondCodeSDNode", ">", "(", "SetCC", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "->", "get", "(", ")", "==", "ISD", "::", "SETNE", ")", ")", ";", "ArrayRef", "<", "EVT", ">", "Res", "(", "Intr", "->", "value_begin", "(", ")", "+", "<NUM_LIT>", ",", "Intr", "->", "value_end", "(", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "BRCOND", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Ops", ".", "append", "(", "Intr", "->", "op_begin", "(", ")", "+", "<NUM_LIT>", ",", "Intr", "->", "op_end", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "Target", ")", ";", "SDNode", "*", "Result", "=", "DAG", ".", "getNode", "(", "Res", ".", "size", "(", ")", ">", "<NUM_LIT>", "?", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "ISD", "::", "INTRINSIC_VOID", ",", "DL", ",", "DAG", ".", "getVTList", "(", "Res", ")", ",", "Ops", ")", ".", "getNode", "(", ")", ";", "if", "(", "BR", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "BR", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "BRCOND", ".", "getOperand", "(", "<NUM_LIT>", ")", "}", ";", "SDValue", "NewBR", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BR", ",", "DL", ",", "BR", "->", "getVTList", "(", ")", ",", "Ops", ")", ";" ]

[ "SVT", ",", "NumElts", "/", "<NUM_LIT>", ")", ";" ]

[ "SDLoc", "DL", "(", "Op", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "{", "MVT", "VecVT", "=", "MVT", "::", "getVectorVT", "(", "VT", ",", "<NUM_LIT>", "/", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VecVT", ",", "In", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITREVERSE", ",", "DL", ",", "VecVT", ",", "Res", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "DL", ",", "VT", ",", "Res", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "DL", ")", ")", ";", "}", "MVT", "SVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "int", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "int", "ScalarSizeInBytes", "=", "VT", ".", "getScalarSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "if", "(", "VT", ".", "is256BitVector", "(", ")", ")", "{", "SDValue", "Lo", "=", "extract128BitVector", "(", "In", ",", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Hi", "=", "extract128BitVector", "(", "In", ",", "NumElts", "/", "<NUM_LIT>", ",", "DAG", ",", "DL", ")", ";", "MVT", "HalfVT", "=", "MVT", "::", "getVectorVT", "(" ]

[ "Disp", ")", ";" ]

[ "void", "addBDXAddrOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands", "<STR_LIT>", ")", ";", "assert", "(", "isMem", "(", "BDXMem", ")", "&&", "<STR_LIT>", "Invalid operand type", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Mem", ".", "Base", ")", ")", ";", "addExpr", "(", "Inst", ",", "Mem", "." ]

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

[ "(", "and", "(", "eq_attr" ]

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

[ "def", "MVE_VSHR_immu16", ":", "MVE_VSHR_imm", "<", "<STR_LIT>", ",", "(", "ins", "shr_imm16", ":", "$", "imm", ")", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ ":" ]

[ "switch", "(", "Instr", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>" ]

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

[ "let", "PredicateMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod" ]

[ "static", "void", "sh_setup_incoming_varargs", "(", "cumulative_args_t", "ca", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_arg_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "gcc_assert", "(", "cfun", "->", "stdarg", ")", ";", "if", "(", "TARGET_VARARGS_PRETEND_ARGS", "(", "current_function_decl", ")", ")", "{", "int", "named_parm_regs", ",", "anon_parm_regs", ";", "named_parm_regs", "=", "(", "sh_round_reg", "(", "*", "get_cumulative_args", "(", "ca", ")", ",", "arg", ".", "mode", ")", "+", "CEIL", "(", "arg", ".", "promoted_size_in_bytes", "(", ")", ",", "UNITS_PER_WORD", ")", ")", ";", "anon_parm_regs", "=", "NPARM_REGS", "(", "SImode", ")", "-", "named_parm_regs", ";", "if", "(", "anon_parm_regs", ">", "<NUM_LIT>", ")", "*", "pretend_arg_size", "=", "anon_parm_regs", "*", "<NUM_LIT>", ";", "}", "}" ]

[ "We", "actually", "emit", "the", "code", "in", "sh_expand_prologue", ".", "We", "used", "to", "use", "a", "static", "variable", "to", "flag", "that", "we", "need", "to", "emit", "this", "code", ",", "but", "that", "does", "n't", "when", "inlining", ",", "when", "functions", "are", "deferred", "and", "then", "emitted", "later", ".", "Fortunately", ",", "we", "already", "have", "two", "flags", "that", "are", "part", "of", "struct", "function", "that", "tell", "if", "a", "function", "uses", "varargs", "or", "stdarg", "." ]

[ "return", "Ctrl", "==", "<STR_LIT>", "row_mirror", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "row_half_mirror", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "quad_perm", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "row_shl", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "row_shr", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "row_ror", "<STR_LIT>", ";" ]

[ "if", "(", "Ctrl", "==", "<STR_LIT>", "row_newbcast", "<STR_LIT>", ")", "return", "isGFX90A", "(", ")", ";", "if", "(", "Ctrl", "==", "<STR_LIT>", "row_share", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "row_xmask", "<STR_LIT>", ")", "return", "isGFX10Plus", "(", ")", ";", "if", "(", "Ctrl", "==", "<STR_LIT>", "wave_shl", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "wave_shr", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "wave_rol", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "wave_ror", "<STR_LIT>", "||", "Ctrl", "==", "<STR_LIT>", "row_bcast", "<STR_LIT>", ")", "return", "isVI", "(", ")", "||", "isGFX9", "(", ")", ";" ]

[ "<STR_LIT>" ]

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

[ "<FIXS>", "if", "(", "mode", "!=", "DFmode", "&&", "mode", "!=", "SFmode", "&&", "mode", "!=", "TFmode", "&&", "mode", "!=", "HFmode", ")", "<FIXE>" ]

[ "{", "case", "REAL_TYPE", ":", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "<BUGS>", "if", "(", "mode", "!=", "DFmode", "&&", "mode", "!=", "SFmode", "&&", "mode", "!=", "TFmode", ")", "<BUGE>", "return", "-", "<NUM_LIT>", ";", "if", "(", "*", "modep", "==", "VOIDmode", ")" ]

[ "<NUM_LIT>", ")", ":", "Type", "::", "getInt32PtrTy", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "unsigned", "char", "OpFlag", "=", "<NUM_LIT>", ";", "unsigned", "WrapperKind", "=", "Subtarget", "->", "isPICStyleRIPRel", "(", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "bool", "PIC32", "=", "(", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", ";", "if", "(", "PIC32", ")", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "OpFlag", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "DebugLoc", "DL", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "SDValue", "Result", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "DL", ",", "GA", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "GA", "->", "getOffset", "(", ")", ",", "OpFlag", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getNode", "(", "WrapperKind", ",", "DL", ",", "getPointerTy", "(", ")", ",", "Result", ")", ";", "if", "(", "PIC32", ")", "Offset", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "getPointerTy", "(", ")", ",", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DebugLoc", "(", ")", ",", "getPointerTy", "(", ")", ")", ",", "Offset", ")", ";", "SDValue", "Chain", "=", "DAG", ".", "getEntryNode", "(", ")", ";", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "SDValue", "Args", "[", "]", "=", "{", "Chain", ",", "Offset", "}", ";", "Chain", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "NodeTys", ",", "Args", ",", "<NUM_LIT>", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MFI", "->", "setAdjustsStack", "(", "true", ")", ";", "unsigned", "Reg", "=", "Subtarget", "->", "is64Bit", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "return", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ",", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "if", "(", "Subtarget", "->", "isTargetWindows", "(", ")", ")", "{", "if", "(", "const", "GlobalAlias", "*", "GA", "=", "dyn_cast", "<", "GlobalAlias", ">", "(", "GV", ")", ")", "GV", "=", "GA", "->", "resolveAliasedGlobal", "(", "false", ")", ";", "DebugLoc", "dl", "=", "GA", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Chain", "=", "DAG", ".", "getEntryNode", "(", ")", ";", "Value", "*", "Ptr", "=", "Constant", "::", "getNullValue", "(", "Subtarget", "->", "is64Bit", "(", ")", "?", "Type", "::", "getInt8PtrTy", "(", "*", "DAG", ".", "getContext", "(", ")", "," ]

[ ";" ]

[ "def", "ExtendOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>" ]

[ ")", "{" ]

[ "SIAnnotateControlFlow", "(", ")", ":", "FunctionPass", "(", "ID" ]

[ "<FIXS>", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "Index", ")", ";", "<FIXE>", "<FIXS>", "Size", ",", "Align", ")", ";", "<FIXE>" ]

[ "}", "int64_t", "FrOffset", "=", "FrameInfo", ".", "getObjectOffset", "(", "Index", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "Index", ")", ";", "MachinePointerInfo", "PtrInfo", "<BUGS>", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "Index", ",", "EltSize", "*", "i", ")", ";", "<BUGE>", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "<BUGS>", "EltSize", ",", "MinAlign", "(", "Align", ",", "EltSize", "*", "i", ")", ")", ";", "<BUGE>", "unsigned", "OffsetReg", "=", "AMDGPU", "::", "M0", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "}", "<FIXE>" ]

[ "case", "LTU", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "<<=", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "<BUGS>", "printf", "(", "<STR_LIT>", "Can't grok '%c' operator:\\n", "<STR_LIT>", ",", "code", ")", ";", "debug_rtx", "(", "x", ")", ";", "<BUGE>", "abort", "(", ")", ";", "<BUGS>", "}", "<BUGE>", "return", ";", "case", "'", "k", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")" ]

[ "Imm", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "int", "SHFIndices", "[", "<NUM_LIT>", "]", "=", "{", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "if", "(", "Indices", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "for", "(", "unsigned", "j", "=", "i", ";", "j", "<", "Indices", ".", "size", "(", ")", ";", "j", "+=", "<NUM_LIT>", ")", "{", "int", "Idx", "=", "Indices", "[", "j", "]", ";", "if", "(", "Idx", "!=", "-", "<NUM_LIT>", ")", "{", "Idx", "-=", "<NUM_LIT>", "*", "(", "j", "/", "<NUM_LIT>", ")", ";", "if", "(", "Idx", "<", "<NUM_LIT>", "||", "Idx", ">=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "}", "if", "(", "SHFIndices", "[", "i", "]", "==", "-", "<NUM_LIT>", ")", "SHFIndices", "[", "i", "]", "=", "Idx", ";", "if", "(", "!", "(", "Idx", "==", "-", "<NUM_LIT>", "||", "Idx", "==", "SHFIndices", "[", "i", "]", ")", ")", "return", "SDValue", "(", ")", ";", "}", "}", "APInt", "Imm", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "--", "i", ")", "{", "int", "Idx", "=", "SHFIndices", "[", "i", "]", ";", "if", "(", "Idx", "==", "-", "<NUM_LIT>", ")", "Idx", "=", "<NUM_LIT>", ";", "Imm", "<<=", "<NUM_LIT>", ";", "Imm", "|=", "Idx", "&", "<NUM_LIT>", ";", "}", "SDLoc", "DL", "(", "Op", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ResTy", ",", "DAG", ".", "getTargetConstant", "(" ]

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

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

[ "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";" ]

[ "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "<FIXE>", "<FIXS>", "case", "OP_TYPE_RN", ":", "return", "OPX_TYPE_RN", ";", "case", "OP_TYPE_FPN", ":", "return", "OPX_TYPE_FPN", ";", "<FIXE>" ]

[ "enum", "attr_opx_typem68k_sched_attr_opx_type", "(", "rtx", "insn", ",", "int", "address_p", ")", "{", "<BUGS>", "sched_guess_p", "=", "(", "get_attr_guess", "(", "insn", ")", "==", "GUESS_YES", ")", ";", "<BUGE>", "switch", "(", "sched_attr_op_type", "(", "insn", ",", "true", ",", "address_p", "!=", "<NUM_LIT>", ")", ")", "{", "<BUGS>", "case", "OP_TYPE_REG", ":", "return", "OPX_TYPE_REG", ";", "<BUGE>", "case", "OP_TYPE_MEM1", ":", "return", "OPX_TYPE_MEM1", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_addsph", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "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", "prefersSlot3", "=" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rm", ";" ]

[ "class", "BaseAddSubEReg", "<", "bit", "isSub", ",", "bit", "setFlags", ",", "RegisterClass", "dstRegtype", ",", "RegisterClass", "src1Regtype", ",", "Operand", "src2Regtype", ",", "string", "asm", ",", "SDPatternOperator", "OpNode", ">", ":", "I", "<", "(", "outs", "dstRegtype", ":", "$", "R1", ")", ",", "(", "ins", "src1Regtype", ":", "$", "R2", ",", "src2Regtype", ":", "$", "R3", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "dstRegtype", ":", "$", "R1", ",", "(", "OpNode", "src1Regtype", ":", "$", "R2", ",", "src2Regtype", ":", "$", "R3", ")", ")", "]", ">", ",", "Sched", "<", "[", "WriteIEReg", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";" ]

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

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

[ ")", "]" ]

[ "(", "lo_sum", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "static", "unsigned", "int", "ix86_minimum_incoming_stack_boundary", "(", "bool", "sibcall", ")", "{", "unsigned", "int", "incoming_stack_boundary", ";", "if", "(", "ix86_user_incoming_stack_boundary", ")", "incoming_stack_boundary", "=", "ix86_user_incoming_stack_boundary", ";", "else", "if", "(", "!", "sibcall", "&&", "!", "TARGET_64BIT", "&&", "ix86_force_align_arg_pointer", "&&", "crtl", "->", "stack_alignment_estimated", "==", "<NUM_LIT>", ")", "incoming_stack_boundary", "=", "MIN_STACK_BOUNDARY", ";", "else", "incoming_stack_boundary", "=", "ix86_default_incoming_stack_boundary", ";", "if", "(", "incoming_stack_boundary", ">", "MIN_STACK_BOUNDARY", "&&", "lookup_attribute", "(", "ix86_force_align_arg_pointer_string", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", ")", "incoming_stack_boundary", "=", "MIN_STACK_BOUNDARY", ";", "if", "(", "incoming_stack_boundary", "<", "crtl", "->", "parm_stack_boundary", ")", "incoming_stack_boundary", "=", "crtl", "->", "parm_stack_boundary", ";", "if", "(", "incoming_stack_boundary", ">", "MAIN_STACK_BOUNDARY", "&&", "DECL_NAME", "(", "current_function_decl", ")", "&&", "MAIN_NAME_P", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", "&&", "DECL_FILE_SCOPE_P", "(", "current_function_decl", ")", ")", "incoming_stack_boundary", "=", "MAIN_STACK_BOUNDARY", ";", "return", "incoming_stack_boundary", ";", "}" ]

[ "Return", "minimum", "incoming", "stack", "alignment", "." ]

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

[ "if", "(", "!", "TARGET_SIDE_EFFECT_PREFIXES", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "MULT", ")", "{", "mult", "=", "INTVAL", "(", "XEXP", "(", "val_rtx", ",", "<NUM_LIT>", ")", ")", ";", "val_rtx", "=", "XEXP", "(", "val_rtx", ",", "<NUM_LIT>", ")", ";", "code", "=", "MULT", ";", "}", "if", "(", "other_op", ">=", "<NUM_LIT>", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ops", "[", "other_op", "]", ")", ")", ">", "UNITS_PER_WORD", ")", "return", "<NUM_LIT>", ";", "if", "(", "(", "cris_base_p", "(", "ops", "[", "lreg", "]", ",", "reload_in_progress", "||", "reload_completed", ")", "&&", "cris_base_p", "(", "ops", "[", "other_op", "]", ",", "reload_in_progress", "||", "reload_completed", ")", "&&", "REGNO", "(", "ops", "[", "lreg", "]", ")", "==", "REGNO", "(", "ops", "[", "other_op", "]", ")", ")", "||", "rtx_equal_p", "(", "ops", "[", "other_op", "]", ",", "ops", "[", "lreg", "]", ")", ")", "return", "<NUM_LIT>", ";", "}", "if", "(", "ops", "[", "lreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rreg", "]", "==", "frame_pointer_rtx", "||", "ops", "[", "rval", "]", "==", "frame_pointer_rtx", "||", "(", "other_op", ">=", "<NUM_LIT>", "&&", "ops", "[", "other_op", "]", "==", "frame_pointer_rtx", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "code", "==", "PLUS", "&&", "!", "cris_base_p", "(", "val_rtx", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "ops", "[", "lreg", "]", ",", "reg_rtx", ")", "&&", "CONST_INT_P", "(", "val_rtx", ")", "&&", "(", "INTVAL", "(", "val_rtx", ")", "<=", "<NUM_LIT>", "&&", "INTVAL", "(", "val_rtx", ")", ">=", "-", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "CONSTANT_P", "(", "val_rtx", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "MEM_P", "(", "val_rtx", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "val_rtx", ",", "<NUM_LIT>", ")", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "val_rtx", ")", "==", "SIGN_EXTEND", "&&", "MEM_P", "(", "XEXP", "(", "val_rtx", ",", "<NUM_LIT>", ")", ")", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "XEXP", "(", "val_rtx", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "else", "if", "(", "code", "==", "MULT", "||", "(", "code", "==", "PLUS", "&&", "cris_base_p", "(", "val_rtx", ",", "reload_in_progress", "||", "reload_completed" ]

[ "VLDMQDB", ":" ]

[ "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "<NUM_LIT>", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "ItinData", "->", "getStageLatency", "(", "get", "(", "Opcode", ")", ".", "getSchedClass", "(", ")", ")", ";", "case", "ARM", "::", "VLDMQIA", ":", "case", "ARM", "::" ]

[ "<FIXS>", "bool", "SelectMUBUF", "(", "SDValue", "Addr", ",", "SDValue", "&", "SRsrc", ",", "SDValue", "&", "VAddr", ",", "<FIXE>" ]

[ "bool", "SelectDS1Addr1Offset", "(", "SDValue", "Ptr", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ")", "const", ";", "bool", "SelectDS64Bit4ByteAligned", "(", "SDValue", "Ptr", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset0", ",", "SDValue", "&", "Offset1", ")", "const", ";", "<BUGS>", "void", "SelectMUBUF", "(", "SDValue", "Addr", ",", "SDValue", "&", "SRsrc", ",", "SDValue", "&", "VAddr", ",", "<BUGE>", "SDValue", "&", "SOffset", ",", "SDValue", "&", "Offset", ",", "SDValue", "&", "Offen", ",", "SDValue", "&", "Idxen", ",", "SDValue", "&", "Addr64", ",", "SDValue", "&", "GLC", ",", "SDValue", "&", "SLC", ",", "SDValue", "&", "TFE", ")", "const", ";" ]

[ "return", "Ret", ";" ]

[ "auto", "Pred", "=", "(", "CmpInst", "::", "Predicate", ")", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getPredicate", "(", ")", ";", "unsigned", "CCReg", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "isSCC", "(", "CCReg", ",", "MRI", ")", ")", "{", "int", "Opcode", "=", "getS_CMPOpcode", "(", "Pred", ",", "Size", ")", ";", "if", "(", "Opcode", "==", "-", "<NUM_LIT>", ")", "return", "false", ";", "MachineInstr", "*", "ICmp", "=", "BuildMI", "(", "*", "BB", ",", "&", "I", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "add", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "BuildMI", "(", "*", "BB", ",", "&", "I", ",", "DL", ",", "TII", ".", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "CCReg", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ")", ";", "bool", "Ret", "=", "constrainSelectedInstRegOperands", "(", "*", "ICmp", ",", "TII", ",", "TRI", ",", "RBI", ")", "&&", "RBI", ".", "constrainGenericRegister", "(", "CCReg", ",", "AMDGPU", "::", "SReg_32RegClass", ",", "MRI", ")", ";", "I", ".", "eraseFromParent", "(", ")", ";" ]

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

[ "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "zero_extend", ":", "DI", "(", "plus", ":", "SI", "(", "match_dup" ]

[ "a", ";" ]

[ "return", "(", "uint64x2_t", ")", "_", "_" ]

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

[ "(", "ior", "(", "match_operand" ]

[ "<FIXS>", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "<FIXE>" ]

[ "MachineBasicBlock", "*", "X86TargetLowering", "::", "EmitSjLjDispatchBlock", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "<BUGS>", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "<BUGE>", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "const", "X86InstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";" ]

[ ")", "]" ]

[ "(", "minus", ":", "SI", "(", "minus", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "geu", ":", "SI", "(", "reg", ":", "CC", "CC_REG", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REG", ")" ]

[ "&", "Operands", ")", "{" ]

[ "OperandMatchResultTy", "parseBDXAddr64", "(", "OperandVector" ]

[ "get", "(", ")", ";" ]

[ "const", "InstructionSelector", "*", "getInstructionSelector", "(", ")", "const", "override", "{", "return", "InstSelector", "." ]

[ "}", ")" ]

[ "emit_insn", "(", "gen_rdgsr_v8plus", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "DONE", "}" ]

[ "false", ";" ]

[ "PM", ".", "add", "(", "createARMObjectCodeEmitterPass", "(", "*", "this", ",", "OCE", ")", ")", ";", "return" ]

[ "<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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=" ]

[ "SllX", ",", "Const1", ")", ";" ]

[ "SDValue", "MipsTargetLowering", "::", "lowerFABS64", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "HasExtractInsert", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "Res", ",", "Const1", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "NoNaNsFPMath", "||", "Subtarget", ".", "inAbs2008Mode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "Op", ".", "getValueType", "(", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "X", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "i64", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "HasExtractInsert", ")", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i64", ",", "DAG", ".", "getRegister", "(", "Mips", "::", "ZERO_64", ",", "MVT", "::", "i64", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "Const1", ",", "X", ")", ";", "else", "{", "SDValue", "SllX", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i64", ",", "X", ",", "Const1", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i64", "," ]

[ "}" ]

[ "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "LRSpillOffset", ")", ";", "MachineLocation", "CSSrc", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MMI", "->", "getFrameMoves", "(", ")", ".", "push_back", "(", "MachineMove", "(", "SaveLRLabel", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}", "}", "}", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "storeToStack", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FPSpillOffset", "+", "FrameSize", "*", "<NUM_LIT>", ",", "dl", ")", ";", "MBB", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "SaveR10Label", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "SaveR10Label", ")", ";", "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "FPSpillOffset", ")", ";", "MachineLocation", "CSSrc", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MMI", "->", "getFrameMoves", "(", ")", ".", "push_back", "(", "MachineMove", "(", "SaveR10Label", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}", "unsigned", "FramePtr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "FramePtr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "FrameLabel", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "FrameLabel", ")", ";", "MachineLocation", "SPDst", "(", "FramePtr", ")", ";", "MachineLocation", "SPSrc", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "MMI", "->", "getFrameMoves", "(", ")", ".", "push_back", "(", "MachineMove", "(", "FrameLabel", ",", "SPDst", ",", "SPSrc", ")", ")", ";", "}", "}", "if", "(", "emitFrameMoves", ")", "{", "std", "::", "vector", "<", "MachineMove", ">", "&", "Moves", "=", "MMI", "->", "getFrameMoves", "(", ")", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "MCSymbol", "*", ",", "CalleeSavedInfo", ">", ">", "&", "SpillLabels", "=", "XFI", "->", "getSpillLabels", "(", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "SpillLabels", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MCSymbol", "*", "SpillLabel", "=", "SpillLabels", "[", "I", "]", ".", "first", ";", "CalleeSavedInfo", "&", "CSI", "=", "SpillLabels", "[", "I", "]", ".", "second", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "CSI", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", ".", "getReg", "(", ")", ";", "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", ")", ";", "MachineLocation", "CSSrc", "(", "Reg", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "SpillLabel", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}" ]

[ ")", "{" ]

[ "}", "SM", ".", "serializeToStackMapSection", "(", ")", ";", "FM", ".", "serializeToFaultMapSection", "(", ")", ";", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "}", "if", "(", "TT", ".", "isKnownWindowsMSVCEnvironment", "(", ")", "&&", "MMI", "->", "usesVAFloatArgument", "(", ")", ")", "{", "StringRef", "SymbolName", "=", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "?", "<STR_LIT>", "_fltused", "<STR_LIT>", ":", "<STR_LIT>", "__fltused", "<STR_LIT>", ";", "MCSymbol", "*", "S", "=", "MMI", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "SymbolName", ")", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "S", ",", "MCSA_Global", ")", ";", "}", "if", "(", "TT", ".", "isOSBinFormatCOFF", "(", ")", ")", "{", "const", "TargetLoweringObjectFileCOFF", "&", "TLOFCOFF", "=", "static_cast", "<", "const", "TargetLoweringObjectFileCOFF", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "std", "::", "string", "Flags", ";", "raw_string_ostream", "FlagsOS", "(", "Flags", ")", ";", "for", "(", "const", "auto", "&", "Function", ":", "M", ")", "TLOFCOFF", ".", "emitLinkerFlagsForGlobal", "(", "FlagsOS", ",", "&", "Function", ",", "*", "Mang", ")", ";", "for", "(", "const", "auto", "&", "Global", ":", "M", ".", "globals", "(", ")", ")", "TLOFCOFF", ".", "emitLinkerFlagsForGlobal", "(", "FlagsOS", ",", "&", "Global", ",", "*", "Mang", ")", ";", "for", "(", "const", "auto", "&", "Alias", ":", "M", ".", "aliases", "(", ")", ")", "TLOFCOFF", ".", "emitLinkerFlagsForGlobal", "(", "FlagsOS", ",", "&", "Alias", ",", "*", "Mang", ")", ";", "FlagsOS", ".", "flush", "(", ")", ";", "if", "(", "!", "Flags", ".", "empty", "(", ")" ]

[ "mmask16", ")", "-", "<NUM_LIT>", ",", "_", "_", "R", ")", ";" ]

[ "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_vfnmaddps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "_", "B", ",", "(", "_", "_", "v16sf", ")", "_", "_", "C", ",", "(", "_", "_" ]

[ "}" ]

[ "let", "ParserMethod", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=", "<STR_LIT>", ";" ]

[ "X", "->", "initMCCodeGenInfo", "(", "RM", ",", "CM", ",", "OL", ")", ";" ]

[ "MCCodeGenInfo", "*", "X", "=", "new", "MCCodeGenInfo", "(", ")", ";", "bool", "is64Bit", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";", "if", "(", "CM", "==", "CodeModel", "::", "Default", ")", "CM", "=", "CodeModel", "::", "Small", ";", "else", "if", "(", "CM", "==", "CodeModel", "::", "JITDefault", ")", "CM", "=", "is64Bit", "?", "CodeModel", "::", "Large", ":", "CodeModel", "::", "Small", ";" ]

[ "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "Register", "&&", "<STR_LIT>", "Invalid type access!", "<STR_LIT>", ")", ";", "return", "Reg", ".", "RegNum", ";", "}" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "]", ")" ]

[ "(", "define_code_iterator", "SZ_EXTEND", "[", "sign_extend", "zero_extend" ]

[ "unsigned", "PatmosInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "FIRST_CUM_REG", ";" ]

[ "for", "(", "regno", "=", "cum", "->", "regno", ";", "regno", "<", "cum", "->", "regno", "+", "bytes", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "fixed register %s used to pass parameter to function", "<STR_LIT>", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "if", "(", "cum", "->", "nregs", "<=", "<NUM_LIT>", ")", "{", "cum", "->", "nregs", "=", "<NUM_LIT>", ";", "cum", "->", "regno", "=" ]

[ "static", "rtx", "tilegx_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "<NUM_LIT>", ")", ";", "unsigned", "int", "fcode", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg", ";", "call_expr_arg_iterator", "iter", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_BUILTIN_ARGS", "+", "<NUM_LIT>", "]", ",", "pat", ";", "int", "opnum", ";", "bool", "nonvoid", ";", "insn_gen_fn", "fn", ";", "if", "(", "fcode", ">=", "TILEGX_BUILTIN_max", ")", "internal_error", "(", "<STR_LIT>", "bad builtin fcode", "<STR_LIT>", ")", ";", "icode", "=", "tilegx_builtin_info", "[", "fcode", "]", ".", "icode", ";", "if", "(", "icode", "==", "<NUM_LIT>", ")", "internal_error", "(", "<STR_LIT>", "bad builtin icode", "<STR_LIT>", ")", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "opnum", "=", "nonvoid", ";", "FOR_EACH_CALL_EXPR_ARG", "(", "arg", ",", "iter", ",", "exp", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "opnum", ">", "MAX_BUILTIN_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "opnum", "]", ";", "op", "[", "opnum", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "opnum", "]", ",", "insn_op", "->", "mode", ")", ")", "{", "machine_mode", "opmode", "=", "insn_op", "->", "mode", ";", "if", "(", "opmode", "==", "VOIDmode", ")", "{", "machine_mode", "m", "=", "GET_MODE", "(", "op", "[", "opnum", "]", ")", ";", "gcc_assert", "(", "m", "==", "Pmode", "||", "m", "==", "VOIDmode", ")", ";", "opmode", "=", "Pmode", ";", "}", "op", "[", "opnum", "]", "=", "copy_to_mode_reg", "(", "opmode", ",", "op", "[", "opnum", "]", ")", ";", "}", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "opnum", "]", ",", "insn_op", "->", "mode", ")", ")", "{", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "<STR_LIT>", "operand must be an immediate of the right size", "<STR_LIT>", ")", ";", "return", "const0_rtx", ";", "}", "opnum", "++", ";", "}", "if", "(", "nonvoid", ")", "{", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "{", "if", "(", "tmode", "==", "VOIDmode", ")", "{", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", ";", "}", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "op", "[", "<NUM_LIT>", "]", "=", "target", ";", "}", "fn", "=", "GEN_FCN", "(", "icode", ")", ";", "switch", "(", "opnum", ")", "{", "case", "<NUM_LIT>", ":", "pat", "=", "fn", "(", "NULL_RTX", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "pat", "=", "fn", "(", "op", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "pat", "=", "fn", "(", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "pat", "=", "fn", "(", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "pat", "=", "fn", "(", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "pat", "=", "fn", "(", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ",", "op", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PREFETCH", ")", "PREFETCH_SCHEDULE_BARRIER_P", "(", "pat", ")", "=", "true", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", "." ]

[ "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";" ]

[ "const", "char", "*", "scratch", "=", "reg_names", "[", "FIRST_ADDRESS_REGNUM", "+", "<NUM_LIT>", "]", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmov %s, %s\\n", "<STR_LIT>", ",", "_", "this", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmov (%s), %s\\n", "<STR_LIT>", ",", "scratch", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd %d, %s\\n", "<STR_LIT>", ",", "(", "int", ")", "vcall_offset", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tmov (%s), %s\\n", "<STR_LIT>", ",", "scratch", ",", "scratch", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "\\tadd %s, %s\\n", "<STR_LIT>", ",", "scratch", ",", "_", "this", ")", ";", "}", "fputs", "(", "<STR_LIT>", "\\tjmp ", "<STR_LIT>", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "putc", "(", "'", "\\n", "'", ",", "file", ")", ";" ]

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

[ "def", "C2_cmoveit", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_5a2711e5", ",", "TypeALU32_2op", ">", ",", "Enc_cda00a", ",", "PredNewRel", ",", "ImmRegRel", "{", "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", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";" ]

[ ")", "_", "_", "base", ",", "_", "_", "offset", ")", ";" ]

[ "_", "_", "arm_vldrhq_gather_shifted_offset_s32", "(", "int16_t", "const", "*", "_", "_", "base", ",", "uint32x4_t", "_", "_", "offset", ")", "{", "return", "_", "_", "builtin_mve_vldrhq_gather_shifted_offset_sv4si", "(", "(", "_", "_", "builtin_neon_hi", "*" ]

[ "bool", "LowerQRegCopyThroughMem", "=", "Subtarget", ".", "hasFPARMv8", "(", ")", "&&", "!", "Subtarget", ".", "isNeonAvailable", "(", ")", "&&", "!", "Subtarget", ".", "hasSVE", "(", ")", ";" ]

[ "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "uint64_t", "NumBytes", "=", "AFI", "->", "getLocalStackSize", "(", ")", ";" ]

[ "}" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "SI", "(", "ashift", ":", "SI", "(", "const_int", "<NUM_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "if", "(", "rx_fuse_in_memory_bitop", "(", "operands", ",", "curr_insn", ",", "&", "gen_bitset_in_memory", ")", ")", "DONE", "else", "FAIL" ]

[ ",", "uint32x4_t", "wk", ")", "{" ]

[ "static", "_", "_", "inline", "uint32x4_t", "vsha1pq_u32", "(", "uint32x4_t", "hash_abcd", ",", "uint32_t", "hash_e" ]

[ "<FIXS>", "DAG", ".", "getIntPtrConstant", "(", "NumBytesToPop", ",", "dl", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "NumBytesForCalleeToPop", ",", "dl", ",", "<FIXE>" ]

[ "if", "(", "!", "IsSibcall", ")", "{", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "<BUGS>", "DAG", ".", "getIntPtrConstant", "(", "NumBytesToPop", ",", "true", ")", ",", "DAG", ".", "getIntPtrConstant", "(", "NumBytesForCalleeToPop", ",", "<BUGE>", "true", ")", ",", "InFlag", ",", "dl", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "emit_insn", "(", "gen_ashlsi_c", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "<FIXE>" ]

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

[ "let", "immOpNum", "=", "!", "if", "(", "Src2IsImm", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";" ]

[ "let", "SrcD", "=", "op4", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "=", "sw", ";", "let", "hasSrcC", "=", "<NUM_LIT>", ";", "let", "hasSrcD", "=", "<NUM_LIT>", ";", "bit", "Src2IsVRF", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Src2", ")", ",", "<STR_LIT>", ")", ";", "bit", "Src4IsVRF", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Src4", ")", ",", "<STR_LIT>", ")", ";", "let", "isNotUsedInDisasm", "=", "!", "if", "(", "!", "and", "(", "Src2IsVRF", ",", "Src4IsVRF", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "bit", "Src2IsImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src2", ")", ";", "bit", "Src4IsImm", "=", "!", "isa", "<", "Operand", ">", "(", "Src4", ")", ";", "let", "HasImm", "=", "!", "or", "(", "Src2IsImm", ",", "Src4IsImm", ")", ";" ]

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

[ "def", "L4_iadd_memoph_zomap", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u5_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_096199d3", ",", "TypeMAPPING", ">", "{", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "<NUM_LIT>", ";" ]

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

[ "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "m128h", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mul_ph", "(" ]

[ "R1", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "XBD2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XBD2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "<FIXS>", "def", "SKLWriteResGroup199", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", ",", "SKLFPDivider", "]", ">", "{", "<FIXE>", "<FIXS>", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "<FIXE>", "<FIXS>", "def", "SKLWriteResGroup201", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", ",", "SKLFPDivider", "]", ">", "{", "<FIXE>", "<FIXS>", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "<FIXE>" ]

[ "}", "def", ":", "InstRW", "[", "SKLWriteResGroup198", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", "SKLWriteResGroup199", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", "]", ">", "{", "<BUGE>", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "<BUGS>", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "<BUGE>", "}", "def", ":", "InstRW", "[", "SKLWriteResGroup199", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";", "<BUGS>", "def", "SKLWriteResGroup201", ":", "SchedWriteRes", "[", "SKLPort0", ",", "SKLPort23", "]", ">", "{", "<BUGE>", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "<BUGS>", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";", "<BUGE>", "}", "def", ":", "InstRW", "[", "SKLWriteResGroup201", "]", ",", "(", "instregex", "<STR_LIT>", ")", ">", ";" ]

[ "else", "if", "(", "SVOp", "->", "getMask", "(", ")", "[", "i", "]", ">=", "<NUM_LIT>", ")", "NumV1OddIndices", "+=", "i", "%", "<NUM_LIT>", ";" ]

[ "}", "int", "NumV1Elements", "=", "<NUM_LIT>", ",", "NumUndefElements", "=", "<NUM_LIT>", ",", "NumV2Elements", "=", "<NUM_LIT>", ";", "for", "(", "int", "M", ":", "SVOp", "->", "getMask", "(", ")", ")", "if", "(", "M", "<", "<NUM_LIT>", ")", "++", "NumUndefElements", ";", "else", "if", "(", "M", "<", "NumElements", ")", "++", "NumV1Elements", ";", "else", "++", "NumV2Elements", ";", "if", "(", "NumV2Elements", ">", "NumV1Elements", ")", "return", "DAG", ".", "getCommutedVectorShuffle", "(", "*", "SVOp", ")", ";", "if", "(", "NumV1Elements", "==", "NumV2Elements", ")", "{", "int", "LowV1Elements", "=", "<NUM_LIT>", ",", "LowV2Elements", "=", "<NUM_LIT>", ";", "for", "(", "int", "M", ":", "SVOp", "->", "getMask", "(", ")", ".", "slice", "(", "<NUM_LIT>", ",", "NumElements", "/", "<NUM_LIT>", ")", ")", "if", "(", "M", ">=", "NumElements", ")", "++", "LowV2Elements", ";", "else", "if", "(", "M", ">=", "<NUM_LIT>", ")", "++", "LowV1Elements", ";", "if", "(", "LowV2Elements", ">", "LowV1Elements", ")", "{", "return", "DAG", ".", "getCommutedVectorShuffle", "(", "*", "SVOp", ")", ";", "}", "else", "if", "(", "LowV2Elements", "==", "LowV1Elements", ")", "{", "int", "SumV1Indices", "=", "<NUM_LIT>", ",", "SumV2Indices", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "Size", "=", "SVOp", "->", "getMask", "(", ")", ".", "size", "(", ")", ";", "i", "<", "Size", ";", "++", "i", ")", "if", "(", "SVOp", "->", "getMask", "(", ")", "[", "i", "]", ">=", "NumElements", ")", "SumV2Indices", "+=", "i", ";", "else", "if", "(", "SVOp", "->", "getMask", "(", ")", "[", "i", "]", ">=", "<NUM_LIT>", ")", "SumV1Indices", "+=", "i", ";", "if", "(", "SumV2Indices", "<", "SumV1Indices", ")", "{", "return", "DAG", ".", "getCommutedVectorShuffle", "(", "*", "SVOp", ")", ";", "}", "else", "if", "(", "SumV2Indices", "==", "SumV1Indices", ")", "{", "int", "NumV1OddIndices", "=", "<NUM_LIT>", ",", "NumV2OddIndices", "=", "<NUM_LIT>", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "Size", "=", "SVOp", "->", "getMask", "(", ")", ".", "size", "(", ")", ";", "i", "<", "Size", ";", "++", "i", ")", "if", "(", "SVOp", "->", "getMask", "(", ")", "[", "i", "]", ">=", "NumElements", ")", "NumV2OddIndices", "+=", "i", "%", "<NUM_LIT>", ";" ]

[ "if", "(", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "<NUM_LIT>", ";" ]

[ "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "<NUM_LIT>", ")", "&", "~", "<NUM_LIT>", ";", "if", "(", "cum", "->", "nbytes", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "<NUM_LIT>", ";", "if", "(", "cum", "->", "nbytes", "+", "size", "<=", "nregs", "*", "UNITS_PER_WORD", ")", "return", "<NUM_LIT>", ";" ]

[ "<FIXS>", "gcc_assert", "(", "REG_P", "(", "addr", ")", "&&", "REGNO", "(", "addr", ")", "!=", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "elsegcc_unreachable", "(", ")", ";", "}", "<BUGS>", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "REG", "&&", "REGNO", "(", "addr", ")", "!=", "<NUM_LIT>", ")", ";", "<BUGE>", "return", "addr", ";", "}" ]

[ "static", "unsigned", "int", "h8300_move_length", "(", "rtx", "*", "operands", ",", "const", "h8300_length_table", "*", "table", ")", "{", "unsigned", "int", "size", ";", "size", "=", "h8300_length_from_table", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "table", ")", ";", "if", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "h8300_short_move_mem_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "POST_INC", ")", ")", "size", "-=", "<NUM_LIT>", ";", "if", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "h8300_short_move_mem_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "PRE_DEC", ")", ")", "size", "-=", "<NUM_LIT>", ";", "return", "size", ";", "}" ]

[ "Calculate", "the", "length", "of", "move", "instruction", "INSN", "using", "the", "given", "length", "table", ".", "Although", "the", "tables", "are", "correct", "for", "most", "cases", ",", "there", "is", "some", "irregularity", "in", "the", "length", "of", "mov.b", "and", "mov.w", ".", "The", "following", "forms", ":", "mov", "@", "ERs+", ",", "Rd", "mov", "@", "(", "d:16", ",", "ERs", ")", ",", "Rd", "mov", "Rs", ",", "@", "-ERd", "mov", "Rs", ",", "@", "(", "d:16", ",", "ERd", ")", "are", "two", "bytes", "shorter", "than", "most", "other", "``", "mov", "Rs", ",", "@", "complex", "''", "or", "``", "mov", "@", "complex", ",", "Rd", "''", "combinations", "." ]

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

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

[ "SDValue", "(", "Res", ",", "<NUM_LIT>", ")", "}", ";" ]

[ "SDValue", "Segment", "=", "DAG", ".", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Src", ".", "isUndef", "(", ")", "||", "ISD", "::", "isBuildVectorAllOnes", "(", "VMask", ".", "getNode", "(", ")", ")", ")", "Src", "=", "getZeroVector", "(", "Op", ".", "getSimpleValueType", "(", ")", ",", "Subtarget", ",", "DAG", ",", "dl", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Src", ",", "VMask", ",", "Base", ",", "Scale", ",", "Index", ",", "Disp", ",", "Segment", ",", "Chain", "}", ";", "SDNode", "*", "Res", "=", "DAG", ".", "getMachineNode", "(", "Opc", ",", "dl", ",", "VTs", ",", "Ops", ")", ";", "SDValue", "RetOps", "[", "]", "=", "{", "SDValue", "(", "Res", ",", "<NUM_LIT>", ")", "," ]

[ "let", "Uses", "=", "[", "P1", "]", ";" ]

[ "def", "J4_cmpgt_tp1_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "GeneralSubRegs", ":", "$", "Rt16", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_56336eb0", ",", "TypeCJ", ">", ",", "Enc_6a5972", ",", "PredRel", "{", "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", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

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

[ "(", "UNSPEC_VCMUL_CONJ", "<STR_LIT>", ")", "(", "UNSPEC_VCMLA180", "<STR_LIT>", ")" ]

[ "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "LABEL_REF", ")", ";" ]

[ "static", "int", "mova_p", "(", "rtx", "insn", ")", "{", "return", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_MOVA", "&&", "GET_CODE", "(", "XVECEXP", "(" ]

[ "<FIXS>", "if", "(", "ArgVT", "==", "MVT", "::", "f32", "||", "ArgVT", "==", "MVT", "::", "f64", ")", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "if", "(", "!", "Flags", ".", "isByVal", "(", ")", ")", "{", "<BUGS>", "if", "(", "ArgVT", "==", "MVT", "::", "f32", "||", "ArgVT", "==", "MVT", "::", "f64", "||", "(", "HasQPX", "&&", "(", "ArgVT", "==", "MVT", "::", "v4f32", "||", "ArgVT", "==", "MVT", "::", "v4f64", "||", "ArgVT", "==", "MVT", "::", "v4i1", ")", ")", ")", "<BUGE>", "if", "(", "AvailableFPRs", ">", "<NUM_LIT>", ")", "{", "<BUGS>", "-", "AvailableFPRs", ";", "<BUGE>", "return", "false", ";" ]

[ "static", "void", "sh_print_operand_address", "(", "FILE", "*", "stream", ",", "machine_mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@%s", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "x", ")", "]", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "index", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "switch", "(", "GET_CODE", "(", "index", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@(%d,%s)", "<STR_LIT>", ",", "(", "int", ")", "INTVAL", "(", "index", ")", ",", "reg_names", "[", "true_regnum", "(", "base", ")", "]", ")", ";", "break", ";", "case", "REG", ":", "case", "SUBREG", ":", "{", "int", "base_num", "=", "true_regnum", "(", "base", ")", ";", "int", "index_num", "=", "true_regnum", "(", "index", ")", ";", "fprintf", "(", "stream", ",", "<STR_LIT>", "@(r0,%s)", "<STR_LIT>", ",", "reg_names", "[", "MAX", "(", "base_num", ",", "index_num", ")", "]", ")", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@-%s", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "stream", ",", "<STR_LIT>", "@%s+", "<STR_LIT>", ",", "reg_names", "[", "true_regnum", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "]", ")", ";", "break", ";", "default", ":", "x", "=", "mark_constant_pool_use", "(", "x", ")", ";", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "}" ]

[ "Print", "the", "operand", "address", "in", "x", "to", "the", "stream", "." ]

[ "}" ]

[ "let", "RenderMethod", "=", "<STR_LIT>", "#", "Scale", "#", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "Scale", "#", "<STR_LIT>", ";", "let", "DiagnosticType", "=", "<STR_LIT>", "#", "Scale", ";" ]

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

[ "(", "plus", ":", "SI", "(", "ashift", ":", "SI", "(", "zero_extend", ":", "SI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rd32", ";" ]

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

[ "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<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", "=", "[", "P0", "]", ";" ]

[ "++", "It", ";" ]

[ "SmallVector", "<", "MachineInstr", "*", ",", "DEFAULT_VEC_SLOTS", ">", "ContInstr", ";", "MachineBasicBlock", "::", "iterator", "Pre", "=", "MBB", "->", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "It", "=", "Pre", ";", "while", "(", "It", "!=", "E", ")", "{", "if", "(", "Pre", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CONTINUE", "&&", "It", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "ENDLOOP", ")", "ContInstr", ".", "push_back", "(", "&", "*", "Pre", ")", ";", "Pre", "=", "It", ";" ]

[ "if", "(", "FBB", ")", "{" ]

[ "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "<STR_LIT>", "Unconditional branch with multiple successors!", "<STR_LIT>", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "<NUM_LIT>", ";", "}", "unsigned", "Count", "=", "<NUM_LIT>", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ";", "++", "Count", ";" ]

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

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

[ "let", "Uses", "=", "[", "USR", "]", ";" ]

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

[ ")", "{" ]

[ "virtual", "SUnit", "*", "pickNode", "(", "bool", "&", "IsTopNode" ]

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

[ "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")" ]

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

[ "class", "BaseN3VCP8ComplexTied", "<", "bit", "op21", ",", "bit", "op4", ",", "bit", "s", ",", "bit", "q", ",", "InstrItinClass", "itin", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "opc", ",", "string", "dt", ",", "list", "<", "dag", ">", "pattern", ">", ":", "N3VCP8", "<", "{", "?", ",", "?", "}", ",", "{", "op21", ",", "s", "}", ",", "q", ",", "op4", ",", "oops", ",", "iops", ",", "itin", ",", "opc", ",", "dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", "{", "bits", "<", "<NUM_LIT>", ">", "rot", ";" ]

[ ")", ",", "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", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc" ]

[ "}" ]

[ "SparcAsmParser", "(", "MCSubtargetInfo", "&", "sti", ",", "MCAsmParser", "&", "parser", ",", "const", "MCInstrInfo", "&", "MII", ")", ":", "MCTargetAsmParser", "(", ")", ",", "STI", "(", "sti", ")", ",", "Parser", "(", "parser", ")", "{", "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";" ]

[ ";" ]

[ "let", "Name", "=", "<STR_LIT>" ]

[ "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "mask", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "Switches", "=", "{", "mask", ",", "<NUM_LIT>", "}", ";", "let", "OperandType", "=", "optype", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "if", "(", "!", "emitIntegerCompare", "(", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MIB", ")", ")", "return", "false", ";" ]

[ "if", "(", "CCMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_TRUNC", ")", "CCMI", "=", "MRI", ".", "getVRegDef", "(", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "CCMI", "->", "getOpcode", "(", ")", "!=", "TargetOpcode", "::", "G_ICMP", ")", "return", "false", ";", "Register", "LHS", "=", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "RHS", "=", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "auto", "VRegAndVal", "=", "getConstantVRegValWithLookThrough", "(", "RHS", ",", "MRI", ")", ";", "if", "(", "!", "VRegAndVal", ")", "std", "::", "swap", "(", "RHS", ",", "LHS", ")", ";", "VRegAndVal", "=", "getConstantVRegValWithLookThrough", "(", "RHS", ",", "MRI", ")", ";", "if", "(", "!", "VRegAndVal", "||", "VRegAndVal", "->", "Value", "!=", "<NUM_LIT>", ")", "{", "MachineIRBuilder", "MIB", "(", "I", ")", ";" ]

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

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

[ "class", "Enc_2d7491", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Ii", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>" ]

[ "a", ";" ]

[ "return", "(", "uint64x1_t", ")", "_", "_" ]