Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "SDValue", "X86TargetLowering", "::", "LowerFCOPYSIGN", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "LLVMContext", "*", "Context", "=", "DAG", ".", "getContext", "(", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Op1", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "dl", "=", "Op", ".", "getDebugLoc", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "EVT", "SrcVT", "=", "Op1", ".", "getValueType", "(", ")", ";", "if", "(", "SrcVT", ".", "bitsLT", "(", "VT", ")", ")", "{", "Op1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "dl", ",", "VT", ",", "Op1", ")", ";", "SrcVT", "=", "VT", ";", "}", "if", "(", "SrcVT", ".", "bitsGT", "(", "VT", ")", ")", "{", "Op1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VT", ",", "Op1", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "SrcVT", "=", "VT", ";", "}", "std", "::", "vector", "<", "Constant", "*", ">", "CV", ";", "if", "(", "SrcVT", "==", "MVT", "::", "f64", ")", "{", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", "ULL", "<<", "<NUM_LIT>", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "}", "else", "{", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", "U", "<<", "<NUM_LIT>", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "}", "Constant", "*", "C", "=", "ConstantVector", "::", "get", "(", "CV", ")", ";", "SDValue", "CPIdx", "=", "DAG", ".", "getConstantPool", "(", "C", ",", "getPointerTy", "(", ")", ",", "<NUM_LIT>", ")", ";", "SDValue", "Mask1", "=", "DAG", ".", "getLoad", "(", "SrcVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "CPIdx", ",", "PseudoSourceValue", "::", "getConstantPool", "(", ")", ",", "<NUM_LIT>", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "SignBit", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "SrcVT", ",", "Op1", ",", "Mask1", ")", ";", "if", "(", "SrcVT", ".", "bitsGT", "(", "VT", ")", ")", "{", "SignBit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v2f64", ",", "SignBit", ")", ";", "SignBit", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "v2f64", ",", "SignBit", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ")", ";", "SignBit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BIT_CONVERT", ",", "dl", ",", "MVT", "::", "v4f32", ",", "SignBit", ")", ";", "SignBit", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "f32", ",", "SignBit", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ")", ")", ";", "}", "CV", ".", "clear", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "{", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "~", "(", "<NUM_LIT>", "ULL", "<<", "<NUM_LIT>", ")", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "}", "else", "{", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "~", "(", "<NUM_LIT>", "U", "<<", "<NUM_LIT>", ")", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", ")", ";", "CV", ".", "push_back", "(", "ConstantFP", "::", "get", "(", "*", "Context", ",", "APFloat", "(", "APInt", "(" ]

[ "}" ]

[ "def", "VST3LNd32_UPD", ":", "VST3LNWB", "<", "<NUM_LIT>", ",", "{", "?", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "<STR_LIT>", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "lane", "{", "<NUM_LIT>", "}", ";" ]

[ ")", ";" ]

[ "vcvtnh_s32_f16", "(", "float16_t", "_", "_", "a", ")", "{", "return", "_", "_", "builtin_aarch64_lfrintnhfsi", "(", "_", "_", "a" ]

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

[ "_", "_", "builtin_aarch64_st1v8hf", "(", "_", "_", "a", "," ]

[ "else", "if", "(", "Lat", ")", "--", "Lat", ";" ]

[ "MachineInstr", "*", "DefI", "=", "Def", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "UseI", "=", "Use", "->", "getInstr", "(", ")", ";", "if", "(", "DefI", "->", "isBundle", "(", ")", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "Reg", "=", "Dep", ".", "getReg", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "DefI", "->", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "DefI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "<NUM_LIT>", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "modifiesRegister", "(", "Reg", ",", "TRI", ")", ")", "Lat", "=", "InstrInfo", ".", "getInstrLatency", "(", "getInstrItineraryData", "(", ")", ",", "*", "I", ")", ";" ]

[ ";" ]

[ "unsigned", "Mods", ";", "std", "::", "tie", "(", "Src", ",", "Mods", ")", "=", "selectVOP3ModsImpl", "(", "Root", ")", ";", "return", "{", "{", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addReg", "(", "Src", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addImm", "(", "Mods", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", ",", "[", "=", "]", "(", "MachineInstrBuilder", "&", "MIB", ")", "{", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "}", "}" ]

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

[ "class", "XForm_26", "<", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "bits", "<", "<NUM_LIT>", ">", "xo", ",", "dag", "OOL", ",", "dag", "IOL", ",", "string", "asmstr", ",", "InstrItinClass", "itin", ",", "list", "<", "dag", ">", "pattern", ">", ":", "XForm_base_r3xo", "<", "opcode", ",", "xo", ",", "OOL", ",", "IOL", ",", "asmstr", ",", "itin", ",", "pattern", ">", "{", "let", "A" ]

[ "OpInfo", "[", "SRsrcIdx", "]", ".", "RegClass", ";" ]

[ "}", "RC", "=", "VRC", ";", "}", "else", "{", "RC", "=", "SRC", ";", "}", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "I", "+=", "<NUM_LIT>", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Op", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineBasicBlock", "*", "InsertBB", "=", "MI", ".", "getOperand", "(", "I", "+", "<NUM_LIT>", ")", ".", "getMBB", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "Insert", "=", "InsertBB", "->", "getFirstTerminator", "(", ")", ";", "legalizeGenericOperand", "(", "*", "InsertBB", ",", "Insert", ",", "RC", ",", "Op", ",", "MRI", ",", "MI", ".", "getDebugLoc", "(", ")", ")", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "getOpRegClass", "(", "MI", ",", "<NUM_LIT>", ")", ";", "if", "(", "RI", ".", "hasVGPRs", "(", "DstRC", ")", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "I", "+=", "<NUM_LIT>", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Op", ".", "getReg", "(", ")", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "OpRC", "=", "MRI", ".", "getRegClass", "(", "Op", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "OpRC", ")", ";", "if", "(", "VRC", "==", "OpRC", ")", "continue", ";", "legalizeGenericOperand", "(", "*", "MBB", ",", "MI", ",", "VRC", ",", "Op", ",", "MRI", ",", "MI", ".", "getDebugLoc", "(", ")", ")", ";", "Op", ".", "setIsKill", "(", ")", ";", "}", "}", "return", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "INSERT_SUBREG", ")", "{", "unsigned", "Dst", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src0", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "Dst", ")", ";", "const", "TargetRegisterClass", "*", "Src0RC", "=", "MRI", ".", "getRegClass", "(", "Src0", ")", ";", "if", "(", "DstRC", "!=", "Src0RC", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "legalizeGenericOperand", "(", "*", "MBB", ",", "MI", ",", "DstRC", ",", "Op", ",", "MRI", ",", "MI", ".", "getDebugLoc", "(", ")", ")", ";", "}", "return", ";", "}", "if", "(", "isMIMG", "(", "MI", ")", "||", "(", "AMDGPU", "::", "isShader", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ")", "&&", "(", "isMUBUF", "(", "MI", ")", "||", "isMTBUF", "(", "MI", ")", ")", ")", ")", "{", "MachineOperand", "*", "SRsrc", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ";", "if", "(", "SRsrc", "&&", "!", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "SRsrc", "->", "getReg", "(", ")", ")", ")", ")", "{", "unsigned", "SGPR", "=", "readlaneVGPRToSGPR", "(", "SRsrc", "->", "getReg", "(", ")", ",", "MI", ",", "MRI", ")", ";", "SRsrc", "->", "setReg", "(", "SGPR", ")", ";", "}", "MachineOperand", "*", "SSamp", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "ssamp", ")", ";", "if", "(", "SSamp", "&&", "!", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "SSamp", "->", "getReg", "(", ")", ")", ")", ")", "{", "unsigned", "SGPR", "=", "readlaneVGPRToSGPR", "(", "SSamp", "->", "getReg", "(", ")", ",", "MI", ",", "MRI", ")", ";", "SSamp", "->", "setReg", "(", "SGPR", ")", ";", "}", "return", ";", "}", "int", "SRsrcIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ";", "if", "(", "SRsrcIdx", "!=", "-", "<NUM_LIT>", ")", "{", "MachineOperand", "*", "SRsrc", "=", "&", "MI", ".", "getOperand", "(", "SRsrcIdx", ")", ";", "unsigned", "SRsrcRC", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", "." ]

[ "else", "llvm_unreachable", "(", "<STR_LIT>", "unknown memory type", "<STR_LIT>", ")", ";" ]

[ "SDNode", "*", "OffsetNode", "=", "Offset", ".", "getNode", "(", ")", ";", "int32_t", "Val", "=", "cast", "<", "ConstantSDNode", ">", "(", "OffsetNode", ")", "->", "getSExtValue", "(", ")", ";", "EVT", "StoredVT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "const", "HexagonInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "if", "(", "TII", "->", "isValidAutoIncImm", "(", "StoredVT", ",", "Val", ")", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "CurDAG", "->", "getTargetConstant", "(", "Val", ",", "MVT", "::", "i32", ")", ",", "Value", ",", "Chain", "}", ";", "unsigned", "Opcode", "=", "<NUM_LIT>", ";", "if", "(", "StoredVT", "==", "MVT", "::", "i64", ")", "Opcode", "=", "Hexagon", "::", "S2_storerd_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i32", ")", "Opcode", "=", "Hexagon", "::", "S2_storeri_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i16", ")", "Opcode", "=", "Hexagon", "::", "S2_storerh_pi", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i8", ")", "Opcode", "=", "Hexagon", "::", "S2_storerb_pi", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "unknown memory type", "<STR_LIT>", ")", ";", "SDNode", "*", "Result", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ")", ";", "MachineSDNode", "::", "mmo_iterator", "MemOp", "=", "MF", "->", "allocateMemRefsArray", "(", "<NUM_LIT>", ")", ";", "MemOp", "[", "<NUM_LIT>", "]", "=", "ST", "->", "getMemOperand", "(", ")", ";", "cast", "<", "MachineSDNode", ">", "(", "Result", ")", "->", "setMemRefs", "(", "MemOp", ",", "MemOp", "+", "<NUM_LIT>", ")", ";", "ReplaceUses", "(", "ST", ",", "Result", ")", ";", "ReplaceUses", "(", "SDValue", "(", "ST", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "Result", ",", "<NUM_LIT>", ")", ")", ";", "return", "Result", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Base", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Value", ",", "Chain", "}", ";", "unsigned", "Opcode", "=", "<NUM_LIT>", ";", "if", "(", "StoredVT", "==", "MVT", "::", "i64", ")", "Opcode", "=", "Hexagon", "::", "S2_storerd_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i32", ")", "Opcode", "=", "Hexagon", "::", "S2_storeri_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i16", ")", "Opcode", "=", "Hexagon", "::", "S2_storerh_io", ";", "else", "if", "(", "StoredVT", "==", "MVT", "::", "i8", ")", "Opcode", "=", "Hexagon", "::", "S2_storerb_io", ";" ]

[ "<FIXS>", "return", "<STR_LIT>", "ashq %2,%D1,%0", "<STR_LIT>", ";", "<FIXE>" ]

[ "{", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "lval", ")", ";", "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "n", ")", ";", "<BUGS>", "return", "<STR_LIT>", "ashq %2,%1,%0", "<STR_LIT>", ";", "<BUGE>", "}", "#", "if", "HOST_BITS_PER_WIDE_INT", "==", "<NUM_LIT>", "}" ]

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

[ "bool", "CheckReturn", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "ArgsFlags", ",", "CCAssignFn" ]

[ "}" ]

[ "createBlocksForVariant", "(", "BlockVariant", ")", ";", "topologicalSort", "(", ")", ";", "scheduleInsideBlocks", "(", ")", ";", "fillStats", "(", ")", ";", "Res", ".", "Blocks", "=", "CurrentBlocks", ";", "Res", ".", "TopDownIndex2Block", "=", "TopDownIndex2Block", ";", "Res", ".", "TopDownBlock2Index", "=", "TopDownBlock2Index", ";", "Blocks", "[", "BlockVariant", "]", "=", "Res", ";", "return", "Res", ";", "}", "else", "{", "return", "B", "->", "second", ";", "}" ]

[ "return", "SDValue", "(", ")", ";" ]

[ "SDValue", "LHS1", ",", "LHS2", ";", "SDValue", "RHS1", ",", "RHS2", ";", "expandf64Toi32", "(", "LHS", ",", "DAG", ",", "LHS1", ",", "LHS2", ")", ";", "expandf64Toi32", "(", "RHS", ",", "DAG", ",", "RHS1", ",", "RHS2", ")", ";", "LHS2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i32", ",", "LHS2", ",", "Mask", ")", ";", "RHS2", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i32", ",", "RHS2", ",", "Mask", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CondCode", "=", "IntCCToARMCC", "(", "CC", ")", ";", "ARMcc", "=", "DAG", ".", "getConstant", "(", "CondCode", ",", "MVT", "::", "i32", ")", ";", "SDVTList", "VTList", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "ARMcc", ",", "LHS1", ",", "LHS2", ",", "RHS1", ",", "RHS2", ",", "Dest", "}", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTList", ",", "Ops", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "int", "WaitStatesNeededForUse", "=", "SmrdSgprWaitStates", "-", "getWaitStatesSinceDef", "(", "Use", ".", "getReg", "(", ")", ",", "IsHazardDefFn", ",", "SmrdSgprWaitStates", ")", ";" ]

[ "int", "SmrdSgprWaitStates", "=", "<NUM_LIT>", ";", "auto", "IsHazardDefFn", "=", "[", "this", "]", "(", "MachineInstr", "*", "MI", ")", "{", "return", "TII", ".", "isVALU", "(", "*", "MI", ")", ";", "}", ";", "auto", "IsBufferHazardDefFn", "=", "[", "this", "]", "(", "MachineInstr", "*", "MI", ")", "{", "return", "TII", ".", "isSALU", "(", "*", "MI", ")", ";", "}", ";", "bool", "IsBufferSMRD", "=", "TII", ".", "isBufferSMRD", "(", "*", "SMRD", ")", ";", "for", "(", "const", "MachineOperand", "&", "Use", ":", "SMRD", "->", "uses", "(", ")", ")", "{", "if", "(", "!", "Use", ".", "isReg", "(", ")", ")", "continue", ";" ]

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

[ "static", "bool", "isRegLiveIn", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "Reg", ")", "{", "for", "(", "MachineBasicBlock", "::", "RegisterMaskPair", "RegMask", ":", "MBB", ".", "liveins", "(", ")", ")", "{", "if", "(", "RegMask", ".", "PhysReg", "==", "Reg", ")", "return", "true", ";", "}" ]

[ "<STR_LIT>", ";" ]

[ "def", "X2AsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "RenderMethod", "=" ]

[ "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "!", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";" ]

[ "static", "bool", "mips_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "const_arith_operand", "(", "x", ",", "Pmode", ")", ")", "return", "false", ";" ]

[ ";" ]

[ "if", "(", "Pred", "->", "NodeNum", "<", "Succ", "->", "NodeNum", ")", "return", "true", ";", "SmallVector", "<", "const", "SUnit", "*", ",", "<NUM_LIT>", ">", "Succs", "(", "{", "Succ", "}", ")", ",", "Preds", "(", "{", "Pred", "}", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "<", "Succs", ".", "size", "(", ")", ";", "++", "I", ")", "{", "for", "(", "const", "SDep", "&", "SI", ":", "Succs", "[", "I", "]", "->", "Succs", ")", "{", "const", "SUnit", "*", "SU", "=", "SI", ".", "getSUnit", "(", ")", ";", "if", "(", "SU", "!=", "Succs", "[", "I", "]", "&&", "llvm", "::", "find", "(", "Succs", ",", "SU", ")", "==", "Succs", ".", "end", "(", ")", ")", "Succs", ".", "push_back", "(", "SU", ")", ";", "}", "}", "SmallPtrSet", "<", "const", "SUnit", "*", ",", "<NUM_LIT>", ">", "Visited", ";", "while", "(", "!", "Preds", ".", "empty", "(", ")", ")", "{", "const", "SUnit", "*", "SU", "=", "Preds", ".", "pop_back_val", "(", ")", ";", "if", "(", "llvm", "::", "find", "(", "Succs", ",", "SU", ")", "!=", "Succs", ".", "end", "(", ")", ")", "return", "false", ";", "Visited", ".", "insert", "(", "SU", ")", ";", "for", "(", "const", "SDep", "&", "SI", ":", "SU", "->", "Preds", ")", "if", "(", "SI", ".", "getSUnit", "(", ")", "!=", "SU", "&&", "!", "Visited", ".", "count", "(", "SI", ".", "getSUnit", "(", ")", ")", ")", "Preds", ".", "push_back", "(", "SI", ".", "getSUnit", "(", ")", ")", ";", "}", "return", "true" ]

[ "MIB", "->", "setDesc", "(", "TII", ".", "get", "(", "X86", "::", "MOV64rm", ")", ")", ";" ]

[ "Register", "Reg", "=", "MIB", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "GlobalValue", ">", "(", "(", "*", "MIB", "->", "memoperands_begin", "(", ")", ")", "->", "getValue", "(", ")", ")", ";", "auto", "Flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ";", "MachineMemOperand", "*", "MMO", "=", "MBB", ".", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getGOT", "(", "*", "MBB", ".", "getParent", "(", ")", ")", ",", "Flags", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64rm", ")", ",", "Reg", ")", ".", "addReg", "(", "X86", "::", "RIP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addGlobalAddress", "(", "GV", ",", "<NUM_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "MIB", "->", "setDebugLoc", "(", "DL", ")", ";" ]

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

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

[ "<FIXS>", "~", "ARMDisassembler", "(", ")", "override", "=", "default", ";", "<FIXE>" ]

[ "MCDisassembler", "(", "STI", ",", "Ctx", ")", "{", "}", "<BUGS>", "~", "ARMDisassembler", "(", ")", "override", "{", "}", "<BUGE>", "DecodeStatus", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", "," ]

[ ")", ";" ]

[ "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(" ]

[ "RegNum", ";" ]

[ "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "(", "Kind", "==", "k_Register", "||", "Kind", "==", "k_WrappedRegister", ")", "&&", "<STR_LIT>", "Invalid access!", "<STR_LIT>", ")", ";", "return", "Reg", "." ]

[ ")", ";" ]

[ "case", "'", "x", "'", ":", "case", "'", "w", "'", ":", "return", "C_RegisterClass", ";", "case", "'", "Q", "'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint" ]

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

[ "def", "imm16_su", ":", "PatLeaf", "<", "(", "i16", "imm", ")", ",", "[", "{", "return", "!", "shouldAvoidImmediateInstFormsForSize", "(", "N", ")", ";", "}", "]", ">", ";", "def", "imm32_su", ":", "PatLeaf", "<", "(", "i32", "imm", ")", ",", "[", "{", "return", "!", "shouldAvoidImmediateInstFormsForSize", "(", "N", ")", ";", "}", "]", ">", ";", "def", "i16immSExt8_su", ":", "PatLeaf", "<", "(" ]

[ "<FIXS>", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "<FIXE>" ]

[ "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "reg", ")", ")", ";", "insn", "=", "emit_frame_insn", "(", "gen_movsi", "(", "mem", ",", "tmp", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "<BUGS>", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "<BUGE>", "}", "break", ";" ]

[ "<FIXS>", "case", "E_DFmode", ":", "case", "E_DImode", ":", "<FIXE>" ]

[ "scan", "=", "emit_insn_after", "(", "gen_consttable_4", "(", "p", "->", "value", ",", "const0_rtx", ")", ",", "scan", ")", ";", "break", ";", "<BUGS>", "case", "DFmode", ":", "case", "DImode", ":", "<BUGE>", "if", "(", "need_align", ")", "{", "need_align", "=", "false", ";" ]

[ "Addr", ",", "Base", ",", "Offset", ")", ";" ]

[ "return", "selectAddrRegImm16", "(", "Addr", ",", "Base", ",", "Offset", ")", "||", "selectAddrDefault", "(" ]

[ "static", "const", "char", "*", "unicosmk_ssib_name", "(", ")", "{", "static", "char", "name", "[", "<NUM_LIT>", "]", ";", "rtx", "x", ";", "const", "char", "*", "fnname", ";", "int", "len", ";", "x", "=", "DECL_RTL", "(", "cfun", "->", "decl", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", "abort", "(", ")", ";", "x", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "abort", "(", ")", ";", "fnname", "=", "XSTR", "(", "x", ",", "<NUM_LIT>", ")", ";", "STRIP_NAME_ENCODING", "(", "fnname", ",", "fnname", ")", ";", "len", "=", "strlen", "(", "fnname", ")", ";", "if", "(", "len", "+", "SSIB_PREFIX_LEN", ">", "<NUM_LIT>", ")", "len", "=", "<NUM_LIT>", "-", "SSIB_PREFIX_LEN", ";", "strcpy", "(", "name", ",", "SSIB_PREFIX", ")", ";", "strncpy", "(", "name", "+", "SSIB_PREFIX_LEN", ",", "fnname", ",", "len", ")", ";", "name", "[", "len", "+", "SSIB_PREFIX_LEN", "]", "=", "<NUM_LIT>", ";", "return", "name", ";", "}" ]

[ "Generate", "the", "name", "of", "the", "SSIB", "section", "for", "the", "current", "function", "." ]

[ "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";" ]

[ "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "assert", "(", "Op", ".", "isImm", "(", ")", "||", "Op", ".", "isExpr", "(", ")", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{" ]

[ "HexagonMCExpr", ">", "(", "Expr", ")", ";" ]

[ "HexagonMCExpr", "const", "&", "HExpr", "=", "cast", "<" ]

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

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

[ "}" ]

[ "class", "VLD3LNWB", "<", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ">", ":", "NLdStLn", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op11_8", ",", "op7_4", ",", "(", "outs", "DPR", ":", "$", "Vd", ",", "DPR", ":", "$", "dst2", ",", "DPR", ":", "$", "dst3", ",", "GPR", ":", "$", "wb", ")", ",", "(", "ins", "addrmode6", ":", "$", "Rn", ",", "am6offset", ":", "$", "Rm", ",", "DPR", ":", "$", "src1", ",", "DPR", ":", "$", "src2", ",", "DPR", ":", "$", "src3", ",", "nohash_imm", ":", "$", "lane", ")", ",", "IIC_VLD3lnu", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVLD2", "]", ">", "{", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

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

[ "(", "define_expand", "<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>", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "FP", ")", ";", "<FIXE>", "<FIXS>", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "Tmp", ")", ";", "<FIXE>" ]

[ "unsigned", "PtrLoadOpc", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "MOV64rm", ":", "X86", "::", "MOV32rm", ";", "unsigned", "IJmpOpc", "=", "(", "PVT", "==", "MVT", "::", "i64", ")", "?", "X86", "::", "JMP64r", ":", "X86", "::", "JMP32r", ";", "<BUGS>", "MachineBasicBlock", "*", "thisMBB", "=", "MBB", ";", "if", "(", "Subtarget", ".", "hasSHSTK", "(", ")", ")", "{", "thisMBB", "=", "emitLongJmpShadowStackFix", "(", "MI", ",", "thisMBB", ")", ";", "}", "MIB", "=", "BuildMI", "(", "thisMBB", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "FP", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "MIB", ".", "add", "(", "MI", ".", "getOperand", "(", "i", ")", ")", ";", "MIB", ".", "setMemRefs", "(", "MMOBegin", ",", "MMOEnd", ")", ";", "<BUGS>", "MIB", "=", "BuildMI", "(", "thisMBB", ",", "DL", ",", "TII", "->", "get", "(", "PtrLoadOpc", ")", ",", "Tmp", ")", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "X86", "::", "AddrNumOperands", ";", "++", "i", ")", "{", "if", "(", "i", "==", "X86", "::", "AddrDisp", ")", "MIB", ".", "addDisp", "(", "MI", ".", "getOperand", "(", "i", ")", ",", "LabelOffset", ")", ";" ]

[ ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_a56825", "{" ]

[ "def", "A2_vaddhs", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")" ]

[ "}" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "BD2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "BD2", ";" ]

[ "<FIXS>", "if", "(", "OffsetRegUsed", ")", "OtherBB", ".", "addLiveIn", "(", "ScratchWaveOffsetReg", ")", ";", "if", "(", "ResourceRegUsed", ")", "OtherBB", ".", "addLiveIn", "(", "ScratchRsrcReg", ")", ";", "<FIXE>", "<FIXS>", "bool", "CopyBuffer", "=", "ResourceRegUsed", "&&", "PreloadedPrivateBufferReg", "!=", "AMDGPU", "::", "NoRegister", "&&", "ScratchRsrcReg", "!=", "PreloadedPrivateBufferReg", ";", "bool", "CopyBufferFirst", "=", "TRI", "->", "isSubRegisterEq", "(", "PreloadedPrivateBufferReg", ",", "ScratchWaveOffsetReg", ")", ";", "if", "(", "CopyBuffer", "&&", "CopyBufferFirst", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "ScratchRsrcReg", ")", ".", "addReg", "(", "PreloadedPrivateBufferReg", ",", "RegState", "::", "Kill", ")", ";", "}", "if", "(", "OffsetRegUsed", "&&", "PreloadedScratchWaveOffsetReg", "!=", "ScratchWaveOffsetReg", ")", "{", "<FIXE>", "<FIXS>", "if", "(", "CopyBuffer", "&&", "!", "CopyBufferFirst", ")", "{", "<FIXE>", "<FIXS>", "}", "if", "(", "ResourceRegUsed", "&&", "PreloadedPrivateBufferReg", "==", "AMDGPU", "::", "NoRegister", ")", "{", "assert", "(", "!", "ST", ".", "isAmdCodeObjectV2", "(", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "&", "OtherBB", "==", "&", "MBB", ")", "continue", ";", "<BUGS>", "OtherBB", ".", "addLiveIn", "(", "ScratchRsrcReg", ")", ";", "OtherBB", ".", "addLiveIn", "(", "ScratchWaveOffsetReg", ")", ";", "<BUGE>", "}", "DebugLoc", "DL", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "<BUGS>", "if", "(", "PreloadedScratchWaveOffsetReg", "!=", "ScratchWaveOffsetReg", ")", "{", "<BUGE>", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "ScratchWaveOffsetReg", ")", ".", "addReg", "(", "PreloadedScratchWaveOffsetReg", ",", "RegState", "::", "Kill", ")", ";", "}", "<BUGS>", "if", "(", "ST", ".", "isAmdCodeObjectV2", "(", ")", ")", "{", "assert", "(", "!", "TRI", "->", "isSubRegisterEq", "(", "PreloadedPrivateBufferReg", ",", "ScratchRsrcReg", ")", "&&", "!", "TRI", "->", "isSubRegisterEq", "(", "PreloadedPrivateBufferReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "<BUGE>", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "ScratchRsrcReg", ")", ".", "addReg", "(", "PreloadedPrivateBufferReg", ",", "RegState", "::", "Kill", ")", ";", "<BUGS>", "}", "else", "{", "<BUGE>", "const", "MCInstrDesc", "&", "SMovB32", "=", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ";", "unsigned", "Rsrc0", "=", "TRI", "->", "getSubReg", "(", "ScratchRsrcReg", ",", "AMDGPU", "::", "sub0", ")", ";" ]

[ "}" ]

[ "bool", "MipsCallEntry", "::", "isAliased", "(", "const", "MachineFrameInfo", "*", ")", "const", "{", "return", "false", ";" ]

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

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

[ "case", "Intrinsic", "::", "amdgcn_s_barrier", ":" ]

[ "return", "selectEndCfIntrinsic", "(", "I", ")", ";", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "return", "selectDSOrderedIntrinsic", "(", "I", ",", "IntrinsicID", ")", ";", "case", "Intrinsic", "::", "amdgcn_ds_gws_init", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_barrier", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_v", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_br", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_p", ":", "case", "Intrinsic", "::", "amdgcn_ds_gws_sema_release_all", ":", "return", "selectDSGWSIntrinsic", "(", "I", ",", "IntrinsicID", ")", ";", "case", "Intrinsic", "::", "amdgcn_ds_append", ":", "return", "selectDSAppendConsume", "(", "I", ",", "true", ")", ";", "case", "Intrinsic", "::", "amdgcn_ds_consume", ":", "return", "selectDSAppendConsume", "(", "I", ",", "false", ")", ";" ]

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

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_cvttps2qq256_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4di", ")", "_", "_", "W" ]

[ "<FIXS>", "def", "M4ReadNMULP2", ":", "SchedReadAdvance", "-", "<NUM_LIT>", ",", "[", "M4WriteNMUL3", "]", ">", ";", "<FIXE>" ]

[ "M4WriteFMAC4H", ",", "M4WriteFMAC5", "]", ">", ";", "def", "M4ReadNMULM1", ":", "SchedReadAdvance", "+", "<NUM_LIT>", ",", "[", "M4WriteNMUL3", "]", ">", ";", "<BUGS>", "def", "M4ReadMULLP2", ":", "SchedReadAdvance", "-", "<NUM_LIT>", ",", "[", "M4WriteNEONM", "]", ">", ";", "<BUGE>" ]

[ "return", "Changed", ";" ]

[ "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "MF", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "Changed", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "llvm", "::", "make_early_inc_range", "(", "MF", ")", ")", "Changed", "|=", "processBlock", "(", "B", ")", ";" ]

[ "}" ]

[ "FunctionPass", "*", "llvm", "::", "createX86FixupLEAs", "(", ")", "{", "return", "new", "FixupLEAPass", "(", ")", ";" ]

[ "bspstore", ";" ]

[ "static", "void", "ia64_handle_unwabi", "(", "struct", "_", "Unwind_Context", "*", "context", ",", "_", "Unwind_FrameState", "*", "fs", ")", "{", "if", "(", "fs", "->", "unwabi", "==", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "'", "s", "'", ")", "||", "fs", "->", "unwabi", "==", "(", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "'", "s", "'", ")", ")", "{", "struct", "sigframe", "{", "char", "scratch", "[", "<NUM_LIT>", "]", ";", "unsigned", "long", "sig_number", ";", "struct", "siginfo", "*", "info", ";", "struct", "sigcontext", "*", "sc", ";", "}", "*", "frame", "=", "(", "struct", "sigframe", "*", ")", "context", "->", "psp", ";", "struct", "sigcontext", "*", "sc", "=", "frame", "->", "sc", ";", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "context", "->", "ireg", "[", "i", "-", "<NUM_LIT>", "]", ".", "loc", "=", "&", "sc", "->", "sc_gr", "[", "i", "]", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "context", "->", "ireg", "[", "i", "-", "<NUM_LIT>", "]", ".", "loc", "=", "&", "sc", "->", "sc_gr", "[", "i", "]", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "context", "->", "ireg", "[", "i", "-", "<NUM_LIT>", "]", ".", "loc", "=", "&", "sc", "->", "sc_gr", "[", "i", "]", ";", "}", "context", "->", "pfs_loc", "=", "&", "(", "sc", "->", "sc_ar_pfs", ")", ";", "context", "->", "lc_loc", "=", "&", "(", "sc", "->", "sc_ar_lc", ")", ";", "context", "->", "unat_loc", "=", "&", "(", "sc", "->", "sc_ar_unat", ")", ";", "context", "->", "br_loc", "[", "<NUM_LIT>", "]", "=", "&", "(", "sc", "->", "sc_br", "[", "<NUM_LIT>", "]", ")", ";", "context", "->", "br_loc", "[", "<NUM_LIT>", "]", "=", "&", "(", "sc", "->", "sc_br", "[", "<NUM_LIT>", "]", ")", ";", "context", "->", "br_loc", "[", "<NUM_LIT>", "]", "=", "&", "(", "sc", "->", "sc_br", "[", "<NUM_LIT>", "]", ")", ";", "context", "->", "pr", "=", "sc", "->", "sc_pr", ";", "context", "->", "gp", "=", "sc", "->", "sc_gr", "[", "<NUM_LIT>", "]", ";", "fs", "->", "no_reg_stack_frame", "=", "<NUM_LIT>", ";", "if", "(", "sc", "->", "sc_rbs_base", ")", "{", "long", "ndirty", ",", "loadrs", "=", "sc", "->", "sc_loadrs", ">>", "<NUM_LIT>", ";", "unsigned", "long", "alt_bspstore", "=", "context", "->", "bsp", "-", "loadrs", ";", "unsigned", "long" ]

[ "b", ",", "uint16x4_t", "_", "_", "c", ")", "{" ]

[ "vmls_u16", "(", "uint16x4_t", "_", "_", "a", ",", "uint16x4_t", "_", "_" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VTs", ",", "&", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", ".", "size", "(", ")", ")", ";" ]

[ "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "Op", ".", "getValueType", "(", ")", ",", "MVT", "::", "Glue", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(", "TrueV", ")", ";", "Ops", ".", "push_back", "(", "FalseV", ")", ";", "Ops", ".", "push_back", "(", "SystemZCC", ")", ";", "Ops", ".", "push_back", "(", "Flag", ")", ";" ]

[ "<NUM_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "EXTSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ne", ":", "EXTSI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "clobber", "(", "match_scratch", ":", "EXTSI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "clz", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "zero_extend", ":", "EXTSI", "(", "lshiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "(", "set", "(", "match_dup" ]

[ "}" ]

[ "class", "AddrMode6Align", ":", "MemOperand", ",", "ComplexPattern", "<", "i32", ",", "<NUM_LIT>", ",", "<STR_LIT>", ",", "[", "]", ",", "[", "SDNPWantParent", "]", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR", ":", "$", "addr", ",", "i32imm", ":", "$", "align", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "<FIXS>", "void", "*", "PPCJITInfo", "::", "emitFunctionStub", "(", "const", "Function", "*", "F", ",", "void", "*", "Fn", ",", "MachineCodeEmitter", "&", "MCE", ")", "{", "<FIXE>", "<FIXS>", "MCE", ".", "startFunctionStub", "(", "F", ",", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "#", "endif", "}", "<BUGS>", "void", "*", "PPCJITInfo", "::", "emitFunctionStub", "(", "void", "*", "Fn", ",", "MachineCodeEmitter", "&", "MCE", ")", "{", "<BUGE>", "if", "(", "Fn", "!=", "(", "void", "*", ")", "(", "intptr_t", ")", "PPC32CompilationCallback", "&&", "Fn", "!=", "(", "void", "*", ")", "(", "intptr_t", ")", "PPC64CompilationCallback", ")", "{", "<BUGS>", "MCE", ".", "startFunctionStub", "(", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "<BUGE>", "intptr_t", "Addr", "=", "(", "intptr_t", ")", "MCE", ".", "getCurrentPCValue", "(", ")", ";", "MCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";" ]

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

[ "def", "L4_loadruh_ur", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "u2_0Imm", ":", "$", "Ii", ",", "u32_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_bab0eed9", ",", "TypeLD", ">", ",", "Enc_4f677b", ",", "AddrModeRel", ",", "ImmRegShl", "{", "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", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";" ]

[ "rtx", "op1", "=", "gen_reg_rtx", "(", "XFmode", ")" ]

[ "<STR_LIT>", "{", "rtx", "op0", "=", "gen_reg_rtx", "(", "XFmode", ")" ]

[ "for", "(", "i", "=", "<NUM_LIT>" ]

[ "<STR_LIT>", "{", "int", "i", "int", "nshift", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "output_asm_insn", "(", "<STR_LIT>", ",", "operands", ")", "output_asm_insn", "(", "<STR_LIT>", ",", "operands", ")" ]

[ ";" ]

[ "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodePSHUFHWMask", "(", "VT", ",", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "IsUnary", "=", "true", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodePSHUFLWMask", "(", "VT", ",", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "IsUnary", "=", "true", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodeVPERMMask", "(", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "IsUnary", "=", "true", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "Mask", ".", "push_back", "(", "NumElems", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "{", "Mask", ".", "push_back", "(", "i", ")", ";", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ImmN", "=", "N", "->", "getOperand", "(", "N", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ";", "DecodeVPERM2X128Mask", "(", "VT", ",", "cast", "<", "ConstantSDNode", ">", "(", "ImmN", ")", "->", "getZExtValue", "(", ")", ",", "Mask", ")", ";", "if", "(", "Mask", ".", "empty", "(", ")", ")", "return", "false", ";", "break", ";", "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>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "false", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unknown target shuffle node", "<STR_LIT>", ")", ";", "}", "return", "true" ]

[ "_", "_", "m128i", "_", "_", "X", ",", "_", "_", "m128i", "_", "_", "Y", ")", "{" ]

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

[ "}" ]

[ "if", "(", "Bytes", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "errOperand", "(", "<NUM_LIT>", ",", "<STR_LIT>", "cannot read literal, inst bytes left ", "<STR_LIT>", "+", "Twine", "(", "Bytes", ".", "size", "(", ")", ")", ")", ";", "return", "MCOperand", "::", "createImm", "(", "eatB32", "(", "Bytes", ")", ")", ";" ]

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

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "dispRI34", ":", "$", "imm", ",", "immZero", ":", "$", "reg", ")", ";", "let", "EncoderMethod" ]

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "use", "(", "match_operand", ":", "VSX_D", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "VSX_D", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "use", "(", "match_operand", ":", "VSX_D", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "rtvec", "v", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", "rtx", "x", "=", "gen_rtx_VEC_CONCAT", "(", "<", "VS_double", ">", "mode", ",", "operands", "[", "<NUM_LIT>" ]

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

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

[ "_", "_", "c", ")", "{" ]

[ "vld1q_lane_p8", "(", "const", "poly8_t", "*", "_", "_", "a", ",", "poly8x16_t", "_", "_", "b", ",", "const", "int" ]

[ "<FIXS>", "~", "R600FrameLowering", "(", ")", "override", ";", "<FIXE>", "<FIXS>", "void", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "override", "{", "}", "void", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "override", "{", "}", "<FIXE>", "<FIXS>", "}", "<FIXE>", "<FIXS>", "#", "endif", "<FIXE>" ]

[ "R600FrameLowering", "(", "StackDirection", "D", ",", "unsigned", "StackAl", ",", "int", "LAO", ",", "unsigned", "TransAl", "=", "<NUM_LIT>", ")", ":", "AMDGPUFrameLowering", "(", "D", ",", "StackAl", ",", "LAO", ",", "TransAl", ")", "{", "}", "<BUGS>", "virtual", "~", "R600FrameLowering", "(", ")", ";", "<BUGE>", "<BUGS>", "void", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "void", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "<BUGE>", "}", ";", "<BUGS>", "}", "<BUGE>", "<BUGS>", "#", "endif", "<BUGE>" ]

[ "<STR_LIT>" ]

[ "(", "match_operand", ":", "XI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VQ", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_VSTRUCTDUMMY", ")", "]" ]

[ "}" ]

[ "assert", "(", "Kind", "==", "k_Memri", "&&", "<STR_LIT>", "Unexpected operand kind", "<STR_LIT>", ")", ";", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "getReg", "(", ")", ")", ")", ";", "addExpr", "(", "Inst", ",", "getImm", "(", ")", ")", ";" ]

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

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

[ "if", "(", "VT", "==", "MVT", "::", "i16", ")", "retval", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "VT", "==", "MVT", "::", "i1", ")", "retval", "=", "<NUM_LIT>", ";", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "retval", "=", "<NUM_LIT>", ";" ]

[ "*", "Src2", ")", ";" ]

[ "MachineInstrBuilder", "Inst32", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "Op32", ")", ")", ".", "setMIFlags", "(", "MI", ".", "getFlags", "(", ")", ")", ";", "if", "(", "AMDGPU", "::", "hasNamedOperand", "(", "Op32", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ")", "{", "Inst32", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "if", "(", "AMDGPU", "::", "hasNamedOperand", "(", "Op32", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ")", "{", "assert", "(", "(", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", ")", "||", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC_LO", ")", ")", "&&", "<STR_LIT>", "Unexpected case", "<STR_LIT>", ")", ";", "}", "Inst32", ".", "add", "(", "*", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ";", "const", "MachineOperand", "*", "Src1", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1", ")", "Inst32", ".", "add", "(", "*", "Src1", ")", ";", "const", "MachineOperand", "*", "Src2", "=", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "Src2", ")", "{", "int", "Op32Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Op32", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "Op32Src2Idx", "!=", "-", "<NUM_LIT>", ")", "{", "Inst32", ".", "add", "(", "*", "Src2", ")", ";", "}", "else", "{", "fixImplicitOperands", "(", "*", "Inst32", ")", ";", "copyFlagsToImplicitVCC", "(", "*", "Inst32", "," ]

[ "}" ]

[ "_", "_", "attribute__", "(", "(", "_", "_", "always_inline__", ",", "_", "_", "gnu_inline__", ",", "_", "_", "artificial__", ")", ")", "vset_lane_f32", "(", "float32_t", "_", "_", "a", ",", "float32x2_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "float32x2_t", ")", "_", "_", "builtin_neon_vset_lanev2sf", "(", "(", "_", "_", "builtin_neon_sf", ")", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

[ "PredAddress", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "PredAddress", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "VectorPred", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "PredPolarity", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

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

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtusepi32_epi16", "(", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pmovusdw128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "mm_avx512_undefined_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "Function", "*", "InitOrFiniKernel", "=", "Function", "::", "createWithDefaultAttr", "(", "FunctionType", "::", "get", "(", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "false", ")", ",", "GlobalValue", "::", "WeakODRLinkage", ",", "<NUM_LIT>", ",", "InitOrFiniKernelName", ",", "&", "M", ")", ";" ]

[ "static", "Function", "*", "createInitOrFiniKernelFunction", "(", "Module", "&", "M", ",", "bool", "IsCtor", ")", "{", "StringRef", "InitOrFiniKernelName", "=", "<STR_LIT>", "amdgcn.device.init", "<STR_LIT>", ";", "if", "(", "!", "IsCtor", ")", "InitOrFiniKernelName", "=", "<STR_LIT>", "amdgcn.device.fini", "<STR_LIT>", ";", "if", "(", "M", ".", "getFunction", "(", "InitOrFiniKernelName", ")", ")", "return", "nullptr", ";" ]

[ "++", "Num2Addrs", ";" ]

[ "bool", "SkipPred", "=", "false", ";", "if", "(", "Pred", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "!", "NewMCID", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "}", "else", "{", "SkipPred", "=", "!", "NewMCID", ".", "isPredicable", "(", ")", ";", "}", "bool", "HasCC", "=", "false", ";", "bool", "CCDead", "=", "false", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "hasOptionalDef", "(", ")", ")", "{", "unsigned", "NumOps", "=", "MCID", ".", "getNumOperands", "(", ")", ";", "HasCC", "=", "(", "MI", "->", "getOperand", "(", "NumOps", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", ")", ";", "if", "(", "HasCC", "&&", "MI", "->", "getOperand", "(", "NumOps", "-", "<NUM_LIT>", ")", ".", "isDead", "(", ")", ")", "CCDead", "=", "true", ";", "}", "if", "(", "!", "VerifyPredAndCC", "(", "MI", ",", "Entry", ",", "true", ",", "Pred", ",", "LiveCPSR", ",", "HasCC", ",", "CCDead", ")", ")", "return", "false", ";", "if", "(", "Entry", ".", "PartFlag", "&&", "NewMCID", ".", "hasOptionalDef", "(", ")", "&&", "HasCC", "&&", "canAddPseudoFlagDep", "(", "MI", ",", "IsSelfLoop", ")", ")", "return", "false", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "NewMCID", ")", ";", "MIB", ".", "add", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "NewMCID", ".", "hasOptionalDef", "(", ")", ")", "MIB", ".", "add", "(", "HasCC", "?", "t1CondCodeOp", "(", "CCDead", ")", ":", "condCodeOp", "(", ")", ")", ";", "unsigned", "NumOps", "=", "MCID", ".", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "<", "NumOps", "&&", "MCID", ".", "OpInfo", "[", "i", "]", ".", "isOptionalDef", "(", ")", ")", "continue", ";", "if", "(", "SkipPred", "&&", "MCID", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ")", "continue", ";", "MIB", ".", "add", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "}", "MIB", ".", "setMIFlags", "(", "MI", "->", "getFlags", "(", ")", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "Converted 32-bit: ", "<STR_LIT>", "<<", "*", "MI", "<<", "<STR_LIT>", " to 16-bit: ", "<STR_LIT>", "<<", "*", "MIB", ")", ";", "MBB", ".", "erase_instr", "(", "MI", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "WordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=", "<STR_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

[ "}" ]

[ "void", "AMDGPUTargetELFStreamer", "::", "EmitDirectiveHSACodeObjectISA", "(", "uint32_t", "Major", ",", "uint32_t", "Minor", ",", "uint32_t", "Stepping", ",", "StringRef", "VendorName", ",", "StringRef", "ArchName", ")", "{", "uint16_t", "VendorNameSize", "=", "VendorName", ".", "size", "(", ")", "+", "<NUM_LIT>", ";", "uint16_t", "ArchNameSize", "=", "ArchName", ".", "size", "(", ")", "+", "<NUM_LIT>", ";", "unsigned", "DescSZ", "=", "sizeof", "(", "VendorNameSize", ")", "+", "sizeof", "(", "ArchNameSize", ")", "+", "sizeof", "(", "Major", ")", "+", "sizeof", "(", "Minor", ")", "+", "sizeof", "(", "Stepping", ")", "+", "VendorNameSize", "+", "ArchNameSize", ";", "EmitAMDGPUNote", "(", "MCConstantExpr", "::", "create", "(", "DescSZ", ",", "getContext", "(", ")", ")", ",", "PT_NOTE", "::", "NT_AMDGPU_HSA_ISA", ",", "[", "&", "]", "(", "MCELFStreamer", "&", "OS", ")", "{", "OS", ".", "EmitIntValue", "(", "VendorNameSize", ",", "<NUM_LIT>", ")", ";", "OS", ".", "EmitIntValue", "(", "ArchNameSize", ",", "<NUM_LIT>", ")", ";", "OS", ".", "EmitIntValue", "(", "Major", ",", "<NUM_LIT>", ")", ";", "OS", ".", "EmitIntValue", "(", "Minor", ",", "<NUM_LIT>", ")", ";", "OS", ".", "EmitIntValue", "(", "Stepping", ",", "<NUM_LIT>", ")", ";", "OS", ".", "EmitBytes", "(", "VendorName", ")", ";", "OS", ".", "EmitIntValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "OS", ".", "EmitBytes", "(", "ArchName", ")", ";", "OS", ".", "EmitIntValue", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "}", ")", ";" ]

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

[ "_", "_", "ev64_opaque__", "t", ";", "t", "=", "_", "_", "ev_mwhumi", "(", "a", ",", "b", ")", ";", "return", "_", "_", "ev_mwumian", "(", "t", ",", "(", "(", "_", "_", "ev64_s32__", ")" ]

[ "<FIXS>", "MOV", "%", "X1", ".", "B", "\\t", "%", "<NUM_LIT>", ",", "%", "<NUM_LIT>", "<FIXE>" ]

[ "<STR_LIT>", ")" ]

[ "_", "p", ")", ";" ]

[ "_", "_", "arm_vcvtmq_m_s32_f32", "(", "int32x4_t", "_", "_", "inactive", ",", "float32x4_t", "_", "_", "a", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vcvtmq_m_sv4si", "(", "_", "_", "inactive", ",", "_", "_", "a", ",", "_" ]

[ "}", ")" ]

[ "if", "(", "GET_MODE", "(", "op", ")", "!", "=", "mode", ")", "return", "<NUM_LIT>", "if", "(", "GET_CODE", "(", "op", ")", "=", "=", "MEM", ")", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", "else", "if", "(", "GET_CODE", "(", "op", ")", "=", "=", "SUBREG", "&", "&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "=", "=", "MEM", "&", "&", "!", "MEM_VOLATILE_P", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", "op", "=", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "else", "return", "<NUM_LIT>", "if", "(", "GET_CODE", "(", "op", ")", "=", "=", "CONST_INT", ")", "{", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "op", ")", "return", "(", "i", ">", "=", "<NUM_LIT>", "&", "&", "i", "<", "<NUM_LIT>", ")", "}", "return", "xstormy16_below100_symbol", "(", "op", ",", "HImode", ")" ]

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

[ "def", "L2_loadrd_pci", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "s4_3Imm", ":", "$", "Ii", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_e93a3d71", ",", "TypeLD", ">", ",", "Enc_b05839", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}" ]

[ "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ")", ";", "}" ]

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

[ "InstrItinClass", ";" ]

[ "def", "tc_56336eb0", ":" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";" ]

[ "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "RetValue", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", "," ]

[ "}" ]

[ "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ "return", ")" ]

[ "[", "(", "set", "(", "reg", ":", "PSI", "SP_REGNO", ")", "(", "plus", ":", "PSI", "(", "reg", ":", "PSI", "SP_REGNO", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(" ]

[ ")", "{" ]

[ "if", "(", "CONST_INT_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "split_double_mode", "(", "mode", ",", "operands", ",", "<NUM_LIT>", ",", "low", ",", "high", ")", ";", "count", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "<NUM_LIT>", ")", ";", "if", "(", "count", "==", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "<NUM_LIT>", ")", "{", "emit_move_insn", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_ashr3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "half_width", "-", "<NUM_LIT>", ")", ")", ")", ";", "emit_move_insn", "(", "low", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "if", "(", "count", ">=", "half_width", ")", "{", "emit_move_insn", "(", "low", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ")", ";", "emit_move_insn", "(", "high", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_ashr3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "half_width", "-", "<NUM_LIT>", ")", ")", ")", ";", "if", "(", "count", ">", "half_width", ")", "emit_insn", "(", "gen_ashr3", "(", "low", "[", "<NUM_LIT>", "]", ",", "low", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "count", "-", "half_width", ")", ")", ")", ";", "}", "else", "{", "gen_shrd", "=", "mode", "==", "DImode", "?", "gen_x86_shrd", ":", "gen_x86_64_shrd", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "emit_insn", "(", "gen_shrd", "(", "low", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "count", ")", ")", ")", ";", "emit_insn", "(", "gen_ashr3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "count", ")", ")", ")", ";", "}", "}", "else", "{", "gen_shrd", "=", "mode", "==", "DImode", "?", "gen_x86_shrd", ":", "gen_x86_64_shrd", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "split_double_mode", "(", "mode", ",", "operands", ",", "<NUM_LIT>", ",", "low", ",", "high", ")", ";", "emit_insn", "(", "gen_shrd", "(", "low", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_ashr3", "(", "high", "[", "<NUM_LIT>", "]", ",", "high", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "if", "(", "TARGET_CMOVE", "&&", "scratch" ]

[ "<FIXS>", "{", "<STR_LIT>", "interrupt", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "false", ",", "interrupt_handler", ",", "NULL", "}", ",", "{", "<STR_LIT>", "bank_switch", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "false", ",", "interrupt_handler", ",", "NULL", "}", ",", "{", "<STR_LIT>", "fast_interrupt", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "false", ",", "interrupt_handler", ",", "NULL", "}", ",", "{", "<STR_LIT>", "function_vector", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ",", "false", ",", "false", ",", "false", ",", "function_vector_handler", ",", "NULL", "}", ",", "{", "NULL", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "false", ",", "NULL", ",", "NULL", "}", "<FIXE>" ]

[ "#", "undef", "TARGET_ATTRIBUTE_TABLE", "#", "define", "TARGET_ATTRIBUTE_TABLE", "m32c_attribute_tablestatic", "const", "struct", "attribute_spec", "m32c_attribute_table", "[", "]", "=", "{", "<BUGS>", "{", "<STR_LIT>", "interrupt", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "interrupt_handler", ",", "false", ",", "NULL", "}", ",", "{", "<STR_LIT>", "bank_switch", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "interrupt_handler", ",", "false", ",", "NULL", "}", ",", "{", "<STR_LIT>", "fast_interrupt", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "false", ",", "interrupt_handler", ",", "false", ",", "NULL", "}", ",", "{", "<STR_LIT>", "function_vector", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "true", ",", "false", ",", "false", ",", "function_vector_handler", ",", "false", ",", "NULL", "}", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ",", "NULL", "}", "<BUGE>", "}", ";", "#", "undef", "TARGET_COMP_TYPE_ATTRIBUTES" ]

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

[ "MCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitByte", "(", "<NUM_LIT>", "+", "<NUM_LIT>", ")", ";", "MCE", ".", "emitWordLE", "(", "(", "unsigned", ")", "(", "intptr_t", ")", "Fn", ")", ";", "MCE", ".", "emitWordLE", "(", "(", "unsigned", ")", "(", "(", "(", "intptr_t", ")", "Fn", ")", ">>", "<NUM_LIT>", ")", ")", ";", "MCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitByte", "(", "<NUM_LIT>", "|", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", ";", "MCE", ".", "startGVStub", "(", "F", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "MCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitWordLE", "(", "(", "intptr_t", ")", "Fn", "-", "MCE", ".", "getCurrentPCValue", "(", ")", "-", "<NUM_LIT>", ")", ";", "return", "MCE", ".", "finishGVStub", "(", "F", ")", ";", "}", "MCE", ".", "startGVStub", "(", "F" ]

[ "<STR_LIT>" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "SDValue", "Call", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "NodeTys", ",", "Ops", ")", ";" ]

[ "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "FPExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "}", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ")", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "DstAddr", ";", "MachinePointerInfo", "DstInfo", ";", "unsigned", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "int32_t", "Offset", "=", "LocMemOffset", ";", "SDValue", "PtrOff", "=", "DAG", ".", "getConstant", "(", "Offset", ",", "DL", ",", "PtrVT", ")", ";", "if", "(", "IsTailCall", ")", "{", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Outs", "[", "realArgIdx", "]", ".", "Flags", ";", "unsigned", "OpSize", "=", "Flags", ".", "isByVal", "(", ")", "?", "Flags", ".", "getByValSize", "(", ")", ":", "VA", ".", "getValVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "Offset", "=", "Offset", "+", "FPDiff", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "OpSize", ",", "Offset", ",", "true", ")", ";", "DstAddr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "PtrVT", ")", ";", "DstInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "Chain", "=", "addTokenForArgument", "(", "Chain", ",", "DAG", ",", "MFI", ",", "FI", ")", ";", "}", "else", "{", "DstAddr", "=", "PtrOff", ";", "DstInfo", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "LocMemOffset", ")", ";", "}", "if", "(", "Outs", "[", "i", "]", ".", "Flags", ".", "isByVal", "(", ")", ")", "{", "SDValue", "SizeNode", "=", "DAG", ".", "getConstant", "(", "Outs", "[", "i", "]", ".", "Flags", ".", "getByValSize", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Cpy", "=", "DAG", ".", "getMemcpy", "(", "Chain", ",", "DL", ",", "DstAddr", ",", "Arg", ",", "SizeNode", ",", "Outs", "[", "i", "]", ".", "Flags", ".", "getByValAlign", "(", ")", ",", "false", ",", "true", ",", "false", ",", "DstInfo", ",", "MachinePointerInfo", "(", "UndefValue", "::", "get", "(", "Type", "::", "getInt8PtrTy", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", ")", ")", ")", ";", "MemOpChains", ".", "push_back", "(", "Cpy", ")", ";", "}", "else", "{", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "Arg", ",", "DstAddr", ",", "DstInfo", ")", ";", "MemOpChains", ".", "push_back", "(", "Store", ")", ";", "}", "}", "}", "passSpecialInputs", "(", "CLI", ",", "CCInfo", ",", "*", "Info", ",", "RegsToPass", ",", "MemOpChains", ",", "Chain", ")", ";", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "DL", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "SDValue", "InFlag", ";", "for", "(", "auto", "&", "RegToPass", ":", "RegsToPass", ")", "{", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "RegToPass", ".", "first", ",", "RegToPass", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "SDValue", "PhysReturnAddrReg", ";", "if", "(", "IsTailCall", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getSubtarget", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "SDValue", "ReturnAddrReg", "=", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_64RegClass", ",", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "MVT", "::", "i64", ")", ";", "PhysReturnAddrReg", "=", "DAG", ".", "getRegister", "(", "TRI", "->", "getReturnAddressReg", "(", "MF", ")", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "PhysReturnAddrReg", ",", "ReturnAddrReg", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "IsTailCall", "&&", "!", "IsSibCall", ")", "{", "Chain", "=", "DAG", ".", "getCALLSEQ_END", "(", "Chain", ",", "DAG", ".", "getTargetConstant", "(", "NumBytes", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "InFlag", ",", "DL", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "std", "::", "vector", "<", "SDValue", ">", "Ops", ";", "Ops", ".", "push_back", "(", "Chain", ")", ";", "Ops", ".", "push_back", "(", "Callee", ")", ";", "if", "(", "IsTailCall", ")", "{", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "FPDiff", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "Ops", ".", "push_back", "(", "PhysReturnAddrReg", ")", ";", "}", "for", "(", "auto", "&", "RegToPass", ":", "RegsToPass", ")", "{", "Ops", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "RegToPass", ".", "first", ",", "RegToPass", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "}", "auto", "*", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "Subtarget", "->", "getRegisterInfo", "(", ")", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "SDVTList", "NodeTys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ")", ";", "if", "(", "IsTailCall", ")", "{", "MFI", ".", "setHasTailCall", "(", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "NodeTys", ",", "Ops", ")", ";", "}" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "XF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_FMOV", ":", "if", "(", "which_alternative", "=", "=", "<NUM_LIT>", ")", "return", "standard_80387_constant_opcode", "(", "operands" ]

[ "<STR_LIT>", ")" ]

[ "(", "set", "(", "match_operand", ":", "HQI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

[ "return_rtx", ";" ]

[ "static", "rtx", "nios2_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "return_rtx", "=", "NULL_RTX", ";", "if", "(", "cum", "->", "regs_used", "<", "NUM_ARG_REGS", ")", "return_rtx", "=", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "FIRST_ARG_REGNO", "+", "cum", "->", "regs_used", ")", ";", "return" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCommutable", "=", "<NUM_LIT>", ";" ]

[ "Ret", "+=", "<STR_LIT>", "-p:32:32", "<STR_LIT>", ";" ]

[ "static", "std", "::", "string", "computeDataLayout", "(", "const", "SparcSubtarget", "&", "ST", ")", "{", "std", "::", "string", "Ret", "=", "<STR_LIT>", "E-m:e", "<STR_LIT>", ";", "if", "(", "!", "ST", ".", "is64Bit", "(", ")", ")" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCommutable", "=", "<NUM_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";" ]

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

[ "<FIXS>", "return", "ScavengeFrameIndexVals", ";", "<FIXE>" ]

[ "}", "bool", "ARMBaseRegisterInfo", "::", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "<BUGS>", "return", "true", ";", "<BUGE>", "}" ]