Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

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

[ ";" ]

[ "const", "SIFrameLowering", "*", "getFrameLowering", "(", ")", "const", "override", "{", "return", "&", "FrameLowering" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "#", "include", "<STR_LIT>", "llvm/Support/CommandLine.h", "<STR_LIT>", "<FIXE>", "<FIXS>", "#", "include", "<STR_LIT>", "llvm/Target/TargetMachine.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "define", "DEBUG_TYPE", "<STR_LIT>", "arm-cp-islands", "<STR_LIT>", "#", "include", "<STR_LIT>", "ARM.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "ARMMachineFunctionInfo.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "Thumb2InstrInfo.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "MCTargetDesc/ARMAddressingModes.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineConstantPool.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineFunctionPass.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineJumpTableInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/CodeGen/MachineRegisterInfo.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/DataLayout.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "llvm/Target/TargetMachine.h", "<STR_LIT>", "<BUGE>", "#", "include", "<STR_LIT>", "llvm/Support/Debug.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/ErrorHandling.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/Format.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/raw_ostream.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "llvm/ADT/SmallSet.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/ADT/SmallVector.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/ADT/STLExtras.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/ADT/Statistic.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/CommandLine.h", "<STR_LIT>", "<BUGE>", "#", "include", "algorithm", ">", "using", "namespace", "llvm", ";" ]

[ ")", ")" ]

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

[ "return", "gcn_expand_dpp_shr_insn", "(", "<", "MODE", ">", "mode", ",", "<STR_LIT>", "," ]

[ "(", "unspec", ":", "V_noHI", "[", "(", "match_operand", ":", "V_noHI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MOV_DPP_SHR", ")", ")", "]", "<STR_LIT>", "{" ]

[ "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

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

[ "}" ]

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

[ "<FIXS>", "<FIXE>", "<FIXS>", "output_addr_const", "(", "file", ",", "op", ")", ";", "return", ";", "<FIXE>" ]

[ "asm_fprintf", "(", "file", ",", "<STR_LIT>", "@", "<STR_LIT>", ")", ";", "break", ";", "<BUGS>", "case", "'", "C", "'", ":", "if", "(", "code", "!=", "MEM", ")", "fatal_insn", "(", "<STR_LIT>", "c4x_print_operand: %%C inconsistency", "<STR_LIT>", ",", "op", ")", ";", "op1", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "SYMBOL_REF_FLAG", "(", "op1", ")", "=", "<NUM_LIT>", ";", "output_addr_const", "(", "file", ",", "op1", ")", ";", "return", ";", "<BUGE>", "case", "'", "H", "'", ":", "<BUGS>", "if", "(", "code", "==", "SYMBOL_REF", ")", "SYMBOL_REF_FLAG", "(", "op", ")", "=", "<NUM_LIT>", ";", "break", ";", "<BUGE>", "case", "'", "I", "'", ":", "code", "=", "reverse_condition", "(", "code", ")", ";" ]

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

[ "}", "llvm_unreachable", "(", "<STR_LIT>", "Unknown fixup kind!", "<STR_LIT>", ")", ";", "}", "namespace", "{", "class", "SystemZMCAsmBackend", ":", "public", "MCAsmBackend", "{", "uint8_t", "OSABI", ";", "public", ":", "SystemZMCAsmBackend", "(", "uint8_t", "osABI", ")", ":", "MCAsmBackend", "(", "support", "::", "big", ")", ",", "OSABI", "(", "osABI", ")", "{", "}", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", ";", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", ";", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "Fragment", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "llvm_unreachable", "(", "<STR_LIT>", "SystemZ does do not have assembler relaxation", "<STR_LIT>", ")", ";", "}", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", ";", "std", "::", "unique_ptr", "<", "MCObjectTargetWriter", ">", "createObjectTargetWriter", "(", ")", "const", "override", "{", "return", "createSystemZObjectWriter", "(", "OSABI", ")", ";", "}", "}", ";", "}", "const", "MCFixupKindInfo", "&", "SystemZMCAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "{", "{", "<STR_LIT>", "FK_390_PC12DBL", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "FK_390_PC16DBL", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "FK_390_PC24DBL", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "FK_390_PC32DBL", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "FK_390_TLS_CALL", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "<STR_LIT>", "Invalid kind!", "<STR_LIT>", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "void", "SystemZMCAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "BitSize", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ";", "unsigned", "Size", "=", "(", "BitSize", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "assert", "(", "Offset", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "<STR_LIT>", "Invalid fixup offset!", "<STR_LIT>", ")", ";", "Value", "=", "extractBitsForFixup", "(", "Kind", ",", "Value", ")", ";", "if", "(", "BitSize", "<", "<NUM_LIT>", ")", "Value", "&=", "(", "(", "uint64_t", ")", "<NUM_LIT>", "<<", "BitSize", ")", "-", "<NUM_LIT>", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zdn", ";", "let", "Constraints", "=" ]

[ ",", "GEPPtrClone", ")", ";" ]

[ "SmallVector", "<", "Value", "*", ",", "<NUM_LIT>", ">", "Indices", ";", "for", "(", "auto", "&", "Index", ":", "cast", "<", "GetElementPtrInst", ">", "(", "GEPPtr", ")", "->", "indices", "(", ")", ")", "Indices", ".", "push_back", "(", "Index", ")", ";", "IRBuilder", "<", ">", "IRB", "(", "cast", "<", "Instruction", ">", "(", "GEPclone", ")", ")", ";", "Value", "*", "GEPPtrClone", "=", "IRB", ".", "CreateGEP", "(", "cast", "<", "GetElementPtrInst", ">", "(", "GEPPtr", ")", "->", "getPointerOperand", "(", ")", ",", "Indices", ")", ";", "cast", "<", "Instruction", ">", "(", "GEPclone", ")", "->", "replaceUsesOfWith", "(", "GEPclonePtr" ]

[ "unsigned", "SrcReg", ";" ]

[ "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "InReg", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "StructRet", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftSelf", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftAsync", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftError", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "Nest", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "Arg", ".", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "ArgTy", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "++", "GPRCnt", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "false", ";", "++", "FPRCnt", ";", "break", ";", "}", "if", "(", "GPRCnt", ">", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "FPRCnt", ">", "<NUM_LIT>", ")", "return", "false", ";", "}", "static", "const", "MCPhysReg", "GPR32ArgRegs", "[", "]", "=", "{", "X86", "::", "EDI", ",", "X86", "::", "ESI", ",", "X86", "::", "EDX", ",", "X86", "::", "ECX", ",", "X86", "::", "R8D", ",", "X86", "::", "R9D", "}", ";", "static", "const", "MCPhysReg", "GPR64ArgRegs", "[", "]", "=", "{", "X86", "::", "RDI", ",", "X86", "::", "RSI", ",", "X86", "::", "RDX", ",", "X86", "::", "RCX", ",", "X86", "::", "R8", ",", "X86", "::", "R9", "}", ";", "static", "const", "MCPhysReg", "XMMArgRegs", "[", "]", "=", "{", "X86", "::", "XMM0", ",", "X86", "::", "XMM1", ",", "X86", "::", "XMM2", ",", "X86", "::", "XMM3", ",", "X86", "::", "XMM4", ",", "X86", "::", "XMM5", ",", "X86", "::", "XMM6", ",", "X86", "::", "XMM7", "}", ";", "unsigned", "GPRIdx", "=", "<NUM_LIT>", ";", "unsigned", "FPRIdx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "const", "&", "Arg", ":", "F", "->", "args", "(", ")", ")", "{", "MVT", "VT", "=", "TLI", ".", "getSimpleValueType", "(", "DL", ",", "Arg", ".", "getType", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TLI", ".", "getRegClassFor", "(", "VT", ")", ";" ]

[ ":", "$", "dst", ")", ",", "(", "OpNode", "(", "v2i64", "V128", ":", "$", "Rd", ")", ",", "(", "v4i32", "V128", ":", "$", "Rn", ")", ")", ")", "]", ">", ";" ]

[ "def", "v4i32_v2i64", ":", "BaseSIMDTwoSameVectorTied", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "opc", ",", "<NUM_LIT>", ",", "V128", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "v2i64", "V128" ]

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

[ "_", "_", "vc16", "=", "(", "_", "_", "vector", "signed", "char", ")", "(", "_", "_", "vector", "unsigned", "long", "long", ")", "{", "_", "_", "A", ",", "_", "_", "A", "}", ";", "_", "_", "vs8", "=", "vec_vupkhsb", "(", "_", "_", "vc16", ")", ";", "_", "_", "vi4", "=", "vec_vupkhsh", "(", "_", "_", "vs8", ")", ";", "_", "_", "vf1", "=", "(", "_", "_", "vector", "float", ")", "vec_ctf", "(", "_", "_" ]

[ ".", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", ")", ")", ";" ]

[ "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "IsNullOrVectorRegister", "=", "!", "RI", ".", "isSGPRClass", "(", "RI", ".", "getRegClassForReg", "(", "MRI", ",", "Reg", ")", ")", ";", "}", "uint16_t", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "return", "IsNullOrVectorRegister", "&&", "(", "isSpill", "(", "Opcode", ")", "||", "(", "!", "MI", ".", "isTerminator", "(", ")", "&&", "Opcode", "!=", "AMDGPU", "::", "COPY", "&&", "MI" ]

[ "if", "(", "N2", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "N2", "=", "DAG", ".", "getIntPtrConstant", "(", "IdxVal", ",", "dl", ")", ";" ]

[ "if", "(", "(", "Subtarget", ".", "hasAVX", "(", ")", "&&", "(", "EltVT", "==", "MVT", "::", "f64", "||", "EltVT", "==", "MVT", "::", "f32", ")", ")", "||", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "EltVT", "==", "MVT", "::", "i32", ")", ")", "{", "SDValue", "N1Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VT", ",", "N1", ")", ";", "N2", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "N0", ",", "N1Vec", ",", "N2", ")", ";", "}", "}", "SDValue", "V", "=", "Extract128BitVector", "(", "N0", ",", "IdxVal", ",", "DAG", ",", "dl", ")", ";", "unsigned", "NumEltsIn128", "=", "<NUM_LIT>", "/", "EltVT", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "NumEltsIn128", ")", ")", ";", "unsigned", "IdxIn128", "=", "IdxVal", "&", "(", "NumEltsIn128", "-", "<NUM_LIT>", ")", ";", "V", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "dl", ",", "V", ".", "getValueType", "(", ")", ",", "V", ",", "N1", ",", "DAG", ".", "getConstant", "(", "IdxIn128", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", "Insert128BitVector", "(", "N0", ",", "V", ",", "IdxVal", ",", "DAG", ",", "dl", ")", ";", "}", "assert", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Only 128-bit vector types should be left!", "<STR_LIT>", ")", ";", "if", "(", "Subtarget", ".", "hasSSE41", "(", ")", ")", "{", "if", "(", "EltVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", "||", "EltVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "unsigned", "Opc", ";", "if", "(", "VT", "==", "MVT", "::", "v8i16", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "assert", "(", "VT", "==", "MVT", "::", "v16i8", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "if", "(", "N1", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "N1", ")", ";", "if", "(", "N2", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "N2", "=", "DAG", ".", "getIntPtrConstant", "(", "IdxVal", ",", "dl", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "VT", ",", "N0", ",", "N1", ",", "N2", ")", ";", "}", "if", "(", "EltVT", "==", "MVT", "::", "f32", ")", "{", "bool", "MinSize", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "if", "(", "IdxVal", "==", "<NUM_LIT>", "&&", "(", "!", "MinSize", "||", "!", "MayFoldLoad", "(", "N1", ")", ")", ")", "{", "N2", "=", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ";", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "N0", ",", "N1", ",", "N2", ")", ";", "}", "N2", "=", "DAG", ".", "getIntPtrConstant", "(", "IdxVal", "<<", "<NUM_LIT>", ",", "dl", ")", ";", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "MVT", "::", "v4f32", ",", "N1", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "N0", ",", "N1", ",", "N2", ")", ";", "}", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", ")", "{", "return", "Op", ";", "}", "}", "if", "(", "EltVT", "==", "MVT", "::", "i8", ")", "return", "SDValue", "(", ")", ";", "if", "(", "EltVT", ".", "getSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "{", "if", "(", "N1", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "N1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "N1", ")", ";" ]

[ "}" ]

[ "void", "AMDGPUInstPrinter", "::", "printIdxen", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "printNamedBit", "(", "MI", ",", "OpNo", ",", "O", ",", "<STR_LIT>", "idxen", "<STR_LIT>", ")", ";" ]

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

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const", "(", "symbol_ref", "<STR_LIT>" ]

[ "<FIXS>", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Ordered blocks:\\n", "<STR_LIT>", ";", "printOrderedBlocks", "(", "dbgs", "(", ")", ")", ";", ")", ";", "<FIXE>" ]

[ "ReverseVector", "(", "or", "deredBlks", ")", ";", "#", "endif", "<BUGS>", "if", "(", "DEBUGME", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "Ordered blocks:\\n", "<STR_LIT>", ";", "printOrderedBlocks", "(", "errs", "(", ")", ")", ";", "}", "<BUGE>", "int", "numIter", "=", "<NUM_LIT>", ";", "bool", "finish", "=", "false", ";", "BlockT", "*", "curBlk", ";" ]

[ "static", "bool", "tilepro_emit_setcc_internal_di", "(", "rtx", "res", ",", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "operands", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ";", "rtx", "tmp", ",", "tmp0", ",", "tmp1", ",", "tmp2", ";", "bool", "swap", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "swap", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "swap", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "tmp", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "tmp", ";", "}", "operands", "[", "<NUM_LIT>", "]", "=", "op0", ";", "operands", "[", "<NUM_LIT>", "]", "=", "op1", ";", "split_di", "(", "operands", ",", "<NUM_LIT>", ",", "lo_half", ",", "hi_half", ")", ";", "if", "(", "!", "reg_or_0_operand", "(", "lo_half", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", "lo_half", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "SImode", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "!", "reg_or_0_operand", "(", "hi_half", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", "hi_half", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "SImode", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "lo_half", "[", "<NUM_LIT>", "]", ")", "&&", "!", "register_operand", "(", "lo_half", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", "lo_half", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "SImode", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "hi_half", "[", "<NUM_LIT>", "]", ")", "&&", "!", "register_operand", "(", "hi_half", "[", "<NUM_LIT>", "]", ",", "SImode", ")", ")", "hi_half", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "SImode", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ";", "tmp0", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "tmp1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "tmp2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "emit_insn", "(", "gen_insn_seq", "(", "tmp0", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_seq", "(", "tmp1", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "res", ",", "tmp0", ",", "tmp1", ")", ")", ";", "return", "true", ";", "break", ";", "case", "NE", ":", "emit_insn", "(", "gen_insn_sne", "(", "tmp0", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_sne", "(", "tmp1", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "res", ",", "tmp0", ",", "tmp1", ")", ")", ";", "return", "true", ";", "break", ";", "case", "LE", ":", "emit_insn", "(", "gen_insn_slte", "(", "tmp0", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_seq", "(", "tmp1", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_slte_u", "(", "tmp2", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_mvnz", "(", "res", ",", "tmp0", ",", "tmp1", ",", "tmp2", ")", ")", ";", "return", "true", ";", "case", "LT", ":", "if", "(", "operands", "[", "<NUM_LIT>", "]", "==", "const0_rtx", ")", "{", "emit_insn", "(", "gen_lshrsi3", "(", "res", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "return", "true", ";", "}", "else", "{", "emit_insn", "(", "gen_insn_slt", "(", "tmp0", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_seq", "(", "tmp1", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_slt_u", "(", "tmp2", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_mvnz", "(", "res", ",", "tmp0", ",", "tmp1", ",", "tmp2", ")", ")", ";", "}", "return", "true", ";", "case", "LEU", ":", "emit_insn", "(", "gen_insn_slte_u", "(", "tmp0", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_seq", "(", "tmp1", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_slte_u", "(", "tmp2", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_mvnz", "(", "res", ",", "tmp0", ",", "tmp1", ",", "tmp2", ")", ")", ";", "return", "true", ";", "case", "LTU", ":", "emit_insn", "(", "gen_insn_slt_u", "(", "tmp0", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_seq", "(", "tmp1", ",", "hi_half", "[", "<NUM_LIT>", "]", ",", "hi_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_slt_u", "(", "tmp2", ",", "lo_half", "[", "<NUM_LIT>", "]", ",", "lo_half", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_mvnz", "(", "res", ",", "tmp0", ",", "tmp1", ",", "tmp2", ")", ")", ";", "return", "true", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}" ]

[ "Helper", "function", "to", "handle", "DImode", "for", "tilepro_emit_setcc_internal", "." ]

[ "rtx", "tmp_lo", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "IFmode", ",", "<NUM_LIT>", ")" ]

[ "(", "unspec", ":", "FMOVE64X", "[", "(", "match_operand", ":", "FMOVE64X", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_P8V_RELOAD_FROM_GPR", ")", ")", "(", "clobber", "(", "match_operand", ":", "IF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rtx", "dest", "=", "operands", "[", "<NUM_LIT>", "]", "rtx", "src", "=", "operands", "[", "<NUM_LIT>", "]", "rtx", "tmp_hi", "=", "simplify_gen_subreg", "(", "DFmode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "IFmode", ",", "<NUM_LIT>", ")" ]

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

[ "bool", "AMDGPUAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".hsa_code_object_version", "<STR_LIT>", ")", "return", "ParseDirectiveHSACodeObjectVersion", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".hsa_code_object_isa", "<STR_LIT>", ")", "return", "ParseDirectiveHSACodeObjectISA", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amd_kernel_code_t", "<STR_LIT>", ")", "return", "ParseDirectiveAMDKernelCodeT", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".hsatext", "<STR_LIT>", "||", "IDVal", "==", "<STR_LIT>", ".text", "<STR_LIT>", ")", "return", "ParseSectionDirectiveHSAText", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgpu_hsa_kernel", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGPUHsaKernel", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgpu_hsa_module_global", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGPUHsaModuleGlobal", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".amdgpu_hsa_program_global", "<STR_LIT>", ")", "return", "ParseDirectiveAMDGPUHsaProgramGlobal", "(", ")", ";", "if", "(", "IDVal", "==", "<STR_LIT>", ".hsadata_global_agent", "<STR_LIT>", ")" ]

[ "(", "X86TTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";" ]

[ "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo" ]

[ "UNSPEC_PRED_X", ")" ]

[ "(", "define_insn_and_rewrite", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SVE_FULL_I", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SVE_FULL_I", "[", "(", "match_operand", ":", "<", "VPRED", ">", "<NUM_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SVE_FULL_I", "[", "(", "match_operand", "<NUM_LIT>", ")", "(", "unspec", ":", "SVE_FULL_I", "[", "(", "match_operand", ":", "SVE_FULL_I", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SVE_FULL_I", "<NUM_LIT>", "<STR_LIT>", ")", "]", "SVE2_COND_INT_BINARY", ")", "]" ]

[ "}", "=", "src1", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "N", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "src2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "<FIXS>", "AddDefaultSrcDestOperands", "(", "Operands", ",", "<STR_LIT>", "::", "<STR_LIT>", "(", "X86", "::", "DX", ",", "NameLoc", ",", "NameLoc", ")", ",", "DefaultMemDIOperand", "(", "NameLoc", ")", ")", ";", "<FIXE>", "<FIXS>", "AddDefaultSrcDestOperands", "(", "Operands", ",", "DefaultMemSIOperand", "(", "NameLoc", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "(", "X86", "::", "DX", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "Name", ".", "startswith", "(", "<STR_LIT>", "ins", "<STR_LIT>", ")", "&&", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "(", "Name", "==", "<STR_LIT>", "insb", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "insw", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "insl", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "insd", "<STR_LIT>", ")", ")", "{", "<BUGS>", "if", "(", "isParsingIntelSyntax", "(", ")", ")", "{", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "X86", "::", "DX", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "Operands", ".", "push_back", "(", "DefaultMemDIOperand", "(", "NameLoc", ")", ")", ";", "}", "else", "{", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "X86", "::", "DX", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "Operands", ".", "push_back", "(", "DefaultMemDIOperand", "(", "NameLoc", ")", ")", ";", "}", "<BUGE>", "}", "if", "(", "Name", ".", "startswith", "(", "<STR_LIT>", "outs", "<STR_LIT>", ")", "&&", "Operands", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "(", "Name", "==", "<STR_LIT>", "outsb", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "outsw", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "outsl", "<STR_LIT>", "||", "Name", "==", "<STR_LIT>", "outsd", "<STR_LIT>", ")", ")", "{", "<BUGS>", "if", "(", "isParsingIntelSyntax", "(", ")", ")", "{", "Operands", ".", "push_back", "(", "DefaultMemSIOperand", "(", "NameLoc", ")", ")", ";", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "X86", "::", "DX", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "else", "{", "Operands", ".", "push_back", "(", "DefaultMemSIOperand", "(", "NameLoc", ")", ")", ";", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "X86", "::", "DX", ",", "NameLoc", ",", "NameLoc", ")", ")", ";", "}", "<BUGE>", "}" ]

[ "<NUM_LIT>", ")", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "break", ";", "case", "ISD", "::", "SUBC", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "ISD", "::", "SUBE", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "ExtraOp", "=", "true", ";", "break", ";", "}", "if", "(", "!", "ExtraOp", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "SDLoc", "(", "Op", ")", ",", "VTs", ",", "Op", ".", "getOperand", "(" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>" ]

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

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

[ "let", "isTaken", "=", "Inst", "{", "<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", "Defs", "=", "[", "PC", "]", ";" ]

[ "<FIXS>", "builder", ".", "register_function_group", "(", "function_groups", "[", "i", "]", ")", ";", "<FIXE>" ]

[ "function_table", "=", "new", "hash_table", "registered_function_hasher", ">", "(", "<NUM_LIT>", ")", ";", "function_builder", "builder", ";", "for", "(", "unsigned", "int", "i", "=", "<NUM_LIT>", ";", "i", "ARRAY_SIZE", "(", "function_groups", ")", ";", "++", "i", ")", "<BUGS>", "if", "(", "!", "(", "function_groups", "[", "i", "]", ".", "required_extensions", "&", "AARCH64_FL_SME", ")", ")", "builder", ".", "register_function_group", "(", "function_groups", "[", "i", "]", ")", ";", "<BUGE>", "}" ]

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

[ "{", "RTX_CODE", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "addend", "=", "<NUM_LIT>", ";", "if", "(", "code", "==", "LABEL_REF", "||", "code", "==", "SYMBOL_REF", ")", "return", "<NUM_LIT>", ";", "if", "(", "code", "==", "CONSTANT_P_RTX", "||", "code", "==", "HIGH", ")", "<BUGS>", "return", "<NUM_LIT>", ";", "<BUGE>", "switch", "(", "code", ")", "{" ]

[ "<STR_LIT>", ")" ]

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

[ ";" ]

[ "offset", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "got_symbol", ")", ",", "UNSPEC_LTREL_OFFSET", ")", ";", "offset", "=", "gen_rtx_CONST", "(", "Pmode", ",", "offset", ")", ";", "offset", "=", "force_const_mem", "(", "Pmode", ",", "offset", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "offset", ")", ";", "offset", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "XEXP", "(", "offset", ",", "<NUM_LIT>", ")", ")", ",", "UNSPEC_LTREL_BASE", ")", ";", "offset", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "got_rtx", ",", "offset", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "offset", ")", ";", "}", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insns" ]

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

[ "extern", "_", "_", "inline", "_", "_", "mmask16", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cmpeq_epu8_mask", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_ucmpb128_mask", "(", "(", "_", "_", "v16qi", ")", "_", "_", "A", ",", "(", "_", "_", "v16qi", ")", "_", "_" ]

[ ")", ";" ]

[ "case", "COND_CLR_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_movt0", "(", "dst", ",", "src", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_movt0", "(", "dst", ",", "dst", ",", "src", ")", ";", "break", ";", "case", "COND_INC_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_incscc", "(", "dst", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_incscc_false", "(", "dst", ",", "dst", ")", ";", "break", ";", "case", "COND_DEC_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_decscc", "(", "dst", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_decscc_false", "(", "dst", ",", "dst", ")", ";", "break", ";", "case", "COND_BRANCH_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_branch_true", "(", "dst", ")", ";", "else", "c_insn", "=", "gen_branch_false", "(", "dst", ")", ";", "break", ";", "default", ":", "return", "NULL", ";", "}", "if", "(", "rtx_length", "[", "GET_CODE", "(", "c_insn", ")", "]", ">=", "<NUM_LIT>", "&&", "rtx_length", "[", "GET_CODE", "(", "insn", ")", "]", ">=", "<NUM_LIT>", ")", "{", "REG_NOTES", "(", "c_insn", ")", "=", "REG_NOTES", "(", "insn", ")", ";", "}", "if", "(", "num", "==", "COND_BRANCH_INSN", ")", "{", "c_insn", "=", "emit_jump_insn_before", "(", "c_insn", ",", "insn" ]

[ "::", "CONSTANT_ADDRESS", ")", "{" ]

[ "bool", "AMDGPUDAGToDAGISel", "::", "isGlobalLoad", "(", "const", "MemSDNode", "*", "N", ")", "const", "{", "if", "(", "!", "N", "->", "readMem", "(", ")", ")", "return", "false", ";", "if", "(", "N", "->", "getAddressSpace", "(", ")", "==", "AMDGPUAS" ]

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

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

[ "<FIXS>", "bit", "HasMods", "=", "<NUM_LIT>", ",", "bit", "useSrc2Input", "=", "<NUM_LIT>", ",", "bit", "VOP3Only", "=", "<NUM_LIT>", ">", "{", "def", "<STR_LIT>", ":", "VOP3_Pseudo", "outs", ",", "ins", ",", "pattern", ",", "opName", ",", "HasMods", ",", "VOP3Only", ">", ";", "<FIXE>", "<FIXS>", "def", "_si", ":", "VOP3b_Real_si", "op", ".", "SI3", ",", "outs", ",", "ins", ",", "asm", ",", "opName", ",", "HasMods", ",", "VOP3Only", ">", ",", "<FIXE>", "<FIXS>", "def", "_vi", ":", "VOP3b_Real_vi", "op", ".", "VI3", ",", "outs", ",", "ins", ",", "asm", ",", "opName", ",", "HasMods", ",", "VOP3Only", ">", ",", "<FIXE>" ]

[ "multiclass", "VOP3b_2_3_m", "vop", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asm", ",", "list", "dag", ">", "pattern", ",", "string", "opName", ",", "string", "revOp", ",", "<BUGS>", "bit", "HasMods", "=", "<NUM_LIT>", ",", "bit", "useSrc2Input", "=", "<NUM_LIT>", ">", "{", "def", "<STR_LIT>", ":", "VOP3_Pseudo", "outs", ",", "ins", ",", "pattern", ",", "opName", ">", ";", "<BUGE>", "<BUGS>", "def", "_si", ":", "VOP3b_Real_si", "op", ".", "SI3", ",", "outs", ",", "ins", ",", "asm", ",", "opName", ">", ",", "<BUGE>", "VOP3DisableFields", "<NUM_LIT>", ",", "useSrc2Input", ",", "HasMods", ">", ";", "<BUGS>", "def", "_vi", ":", "VOP3b_Real_vi", "op", ".", "VI3", ",", "outs", ",", "ins", ",", "asm", ",", "opName", ">", ",", "<BUGE>", "VOP3DisableFields", "<NUM_LIT>", ",", "useSrc2Input", ",", "HasMods", ">", ";", "}" ]

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

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

[ "m512i", "_", "_", "W", ",", "_", "_", "mmask32", "_", "_", "M", ",", "_", "_", "m512i", "_", "_", "A", ",", "_", "_", "m512i", "_", "_", "B", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_packs_epi32", "(", "_", "_" ]

[ "}" ]

[ "aarch64_builtin_decls", "[", "AARCH64_PAUTH_BUILTIN_AUTIB1716", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_autib1716", "<STR_LIT>", ",", "ftype_pointer_auth", ",", "AARCH64_PAUTH_BUILTIN_AUTIB1716", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_PAUTH_BUILTIN_PACIB1716", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_pacib1716", "<STR_LIT>", ",", "ftype_pointer_auth", ",", "AARCH64_PAUTH_BUILTIN_PACIB1716", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_PAUTH_BUILTIN_XPACLRI", "]", "=", "aarch64_general_add_builtin", "(", "<STR_LIT>", "__builtin_aarch64_xpaclri", "<STR_LIT>", ",", "ftype_pointer_strip", ",", "AARCH64_PAUTH_BUILTIN_XPACLRI", ")", ";" ]

[ "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";" ]

[ "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STM", "=", "&", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", "->", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", "->", "getInstrInfo", "(", ")", ";" ]

[ "}" ]

[ "if", "(", "TARGET_64BIT", "&&", "mode", "==", "SImode", "&&", "mode_rep", "==", "DImode", ")", "return", "SIGN_EXTEND", ";", "return", "UNKNOWN", ";" ]

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

[ "gcc_unreachable", "(", ")", "}", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr_alternative", "<STR_LIT>", "[", "(", "if_then_else", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "]", ")", "(", "set_attr" ]

[ "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "Rs", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "hasSideEffects", "=", "<NUM_LIT>", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "+", "VA", ".", "getLocMemOffset", "(", ")", ";" ]

[ "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUASI", ".", "CONSTANT_BUFFER_0", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "Subtarget", "->", "getExplicitKernelArgOffset", "(", "MF", ")" ]

[ ",", "v256f64", ":", "$", "vz", ",", "i32", ":", "$", "vl", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "int_ve_vl_vfmklne_mvl", "v256f64", ":", "$", "vz", ",", "i32", ":", "$", "vl", ")", ",", "(", "VFMKLvl", "CC_INE" ]

[ "unsigned", "ARMAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "unsigned", "Opc", "=", "Inst", ".", "getOpcode", "(", ")", ";", "MCInstrDesc", "&", "MCID", "=", "getInstDesc", "(", "Opc", ")", ";", "if", "(", "MCID", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "assert", "(", "MCID", ".", "hasOptionalDef", "(", ")", "&&", "<STR_LIT>", "optionally flag setting instruction missing optional def operand", "<STR_LIT>", ")", ";", "assert", "(", "MCID", ".", "NumOperands", "==", "Inst", ".", "getNumOperands", "(", ")", "&&", "<STR_LIT>", "operand count mismatch!", "<STR_LIT>", ")", ";", "unsigned", "OpNo", ";", "for", "(", "OpNo", "=", "<NUM_LIT>", ";", "!", "MCID", ".", "OpInfo", "[", "OpNo", "]", ".", "isOptionalDef", "(", ")", "&&", "OpNo", "<", "MCID", ".", "NumOperands", ";", "++", "OpNo", ")", ";", "if", "(", "isThumbOne", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "return", "Match_MnemonicFail", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", "&&", "!", "inITBlock", "(", ")", ")", "return", "Match_RequiresITBlock", ";", "if", "(", "isThumbTwo", "(", ")", "&&", "Inst", ".", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "CPSR", "&&", "inITBlock", "(", ")", ")", "return", "Match_RequiresNotITBlock", ";", "}", "else", "if", "(", "Opc", "==", "ARM", "::", "tADDhirr", "&&", "isThumbOne", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresThumb2", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tMOVr", "&&", "isThumbOne", "(", ")", "&&", "!", "hasV6Ops", "(", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "&&", "isARMLowRegister", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "return", "Match_RequiresV6", ";", "return", "Match_Success", ";", "}" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

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

[ "}", "else", "if", "(", "(", "outer", "==", "PLUS", "||", "outer", "==", "COMPARE", ")", "&&", "INTVAL", "(", "x", ")", "<", "<NUM_LIT>", "&&", "INTVAL", "(", "x", ")", ">", "-", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "else", "if", "(", "(", "outer", "==", "IOR", "||", "outer", "==", "XOR", "||", "outer", "==", "AND", ")", "&&", "INTVAL", "(", "x", ")", "<", "<NUM_LIT>", "&&", "INTVAL", "(", "x", ")", ">=", "-", "<NUM_LIT>", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "outer", "==", "AND", ")", "{", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<=", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "(", "HOST_WIDE_INT_1", "<<", "i", ")", "-", "<NUM_LIT>", "==", "INTVAL", "(", "x", ")", "||", "(", "HOST_WIDE_INT_1", "<<", "i", ")", "-", "<NUM_LIT>", "==", "~", "INTVAL", "(", "x", ")", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "outer", "==", "ASHIFT", "||", "outer", "==", "ASHIFTRT", "||", "outer", "==", "LSHIFTRT", ")", "return", "<NUM_LIT>", ";", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "case", "CONST", ":", "case", "CONST_DOUBLE", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "case", "UDIV", ":", "case", "UMOD", ":", "case", "DIV", ":", "case", "MOD", ":", "return", "<NUM_LIT>", ";", "case", "TRUNCATE", ":", "return", "<NUM_LIT>", ";", "case", "AND", ":", "case", "XOR", ":", "case", "IOR", ":", "return", "<NUM_LIT>", ";", "case", "MEM", ":", "return", "(", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "-", "<NUM_LIT>", ")", "/", "UNITS_PER_WORD", ")", "+", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "case", "IF_THEN_ELSE", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PC", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PC", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "case", "SIGN_EXTEND", ":", "case", "ZERO_EXTEND", ":", "total", "=", "mode", "==", "DImode", "?", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ":", "<NUM_LIT>", ";", "total", "+=", "thumb1_rtx_costs", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ",", "code", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "total", ";", "if", "(", "arm_arch6", ")", "return", "total", "+", "COSTS_N_INSNS" ]

[ "}" ]

[ "let", "ParserMatchClass", "=", "VecListThreeQHWordIndexAsmOperand", ";", "let", "MIOperandInfo", "=", "(", "ops", "DPR", ":", "$", "Vd", ",", "i32imm", ":", "$", "idx", ")", ";" ]

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

[ "def", "L4_ior_memoph_io", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "u31_1Imm", ":", "$", "Ii", ",", "u5_0Imm", ":", "$", "II", ")", ",", "<STR_LIT>", ",", "tc_096199d3", ",", "TypeV4LDST", ">", ",", "Enc_e66a97", "{", "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", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ "bool", "xlogue_layout", "::", "is_stub_managed_reg", "(", "unsigned", "regno", ",", "unsigned", "count", ")", "{", "bool", "hfp", "=", "frame_pointer_needed", "||", "stack_realign_fp", ";", "unsigned", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "count", ";", "++", "i", ")", "{", "gcc_assert", "(", "i", "<", "MAX_REGS", ")", ";", "if", "(", "REG_ORDER", "[", "i", "]", "==", "BP_REG", "&&", "hfp", ")", "++", "count", ";", "else", "if", "(", "REG_ORDER", "[", "i", "]", "==", "regno", ")", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Determine", "if", "register", "REGNO", "is", "a", "stub", "managed", "register", "given", "the", "total", "COUNT", "of", "stub", "managed", "registers", "." ]

[ "}" ]

[ "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "getPointerTy", "(", ")", ",", "StackPtr", ",", "PtrOff", ")", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "return", "CreateCopyOfByValArgument", "(", "Arg", ",", "PtrOff", ",", "Chain", ",", "Flags", ",", "DAG", ",", "dl", ")", ";", "}", "return", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "PseudoSourceValue", "::", "getStack", "(", ")", ",", "LocMemOffset", ")", ";" ]

[ "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "(", "unspec_volatile", ":", "SI", "[", "<FIXE>", "<FIXS>", "]", "<NUM_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGS>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "<BUGS>", "(", "unspec", ":", "SI", "[", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "]", "<NUM_LIT>", ")", ")", "(", "set", "(", "reg", ":", "SI", "<NUM_LIT>", ")", "(", "unspec", ":", "SI", "[", "<BUGE>", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", "<BUGS>", "]", "<NUM_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "invalid shift/extend specified, expected 'z[0..31].d, lsl #3'", "<STR_LIT>", ")", ";" ]

[ "case", "Match_InvalidImm0_15", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 15].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm0_31", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 31].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm0_63", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 63].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm0_127", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 127].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm0_255", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 255].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm0_65535", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 65535].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm1_8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [1, 8].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm1_16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [1, 16].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm1_32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [1, 32].", "<STR_LIT>", ")", ";", "case", "Match_InvalidImm1_64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [1, 64].", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEAddSubImm8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 255]", "<STR_LIT>", "<STR_LIT>", " with a shift amount of 0", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEAddSubImm16", ":", "case", "Match_InvalidSVEAddSubImm32", ":", "case", "Match_InvalidSVEAddSubImm64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [0, 255] or a ", "<STR_LIT>", "<STR_LIT>", "multiple of 256 in range [256, 65280]", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVECpyImm8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [-128, 255]", "<STR_LIT>", "<STR_LIT>", " with a shift amount of 0", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVECpyImm16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [-128, 127] or a ", "<STR_LIT>", "<STR_LIT>", "multiple of 256 in range [-32768, 65280]", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVECpyImm32", ":", "case", "Match_InvalidSVECpyImm64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "immediate must be an integer in range [-128, 127] or a ", "<STR_LIT>", "<STR_LIT>", "multiple of 256 in range [-32768, 32512]", "<STR_LIT>", ")", ";", "case", "Match_InvalidIndexRange1_1", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "expected lane specifier '[1]'", "<STR_LIT>", ")", ";", "case", "Match_InvalidIndexRange0_15", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 15].", "<STR_LIT>", ")", ";", "case", "Match_InvalidIndexRange0_7", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 7].", "<STR_LIT>", ")", ";", "case", "Match_InvalidIndexRange0_3", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 3].", "<STR_LIT>", ")", ";", "case", "Match_InvalidIndexRange0_1", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 1].", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEIndexRange0_63", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 63].", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEIndexRange0_31", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 31].", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEIndexRange0_15", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 15].", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEIndexRange0_7", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 7].", "<STR_LIT>", ")", ";", "case", "Match_InvalidSVEIndexRange0_3", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "vector lane must be an integer in range [0, 3].", "<STR_LIT>", ")", ";", "case", "Match_InvalidLabel", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "expected label or encodable integer pc offset", "<STR_LIT>", ")", ";", "case", "Match_MRS", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "expected readable system register", "<STR_LIT>", ")", ";", "case", "Match_MSR", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "expected writable system register or pstate", "<STR_LIT>", ")", ";", "case", "Match_InvalidComplexRotationEven", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "complex rotation must be 0, 90, 180 or 270.", "<STR_LIT>", ")", ";", "case", "Match_InvalidComplexRotationOdd", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "complex rotation must be 90 or 270.", "<STR_LIT>", ")", ";", "case", "Match_MnemonicFail", ":", "{", "std", "::", "string", "Suggestion", "=", "AArch64MnemonicSpellCheck", "(", "(", "(", "AArch64Operand", "&", ")", "*", "Operands", "[", "<NUM_LIT>", "]", ")", ".", "getToken", "(", ")", ",", "ComputeAvailableFeatures", "(", "STI", "->", "getFeatureBits", "(", ")", ")", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unrecognized instruction mnemonic", "<STR_LIT>", "+", "Suggestion", ")", ";", "}", "case", "Match_InvalidGPR64shifted8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 or xzr, without shift", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64shifted16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 or xzr, with required shift 'lsl #1'", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64shifted32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 or xzr, with required shift 'lsl #2'", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64shifted64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 or xzr, with required shift 'lsl #3'", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64NoXZRshifted8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 without shift", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64NoXZRshifted16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 with required shift 'lsl #1'", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64NoXZRshifted32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 with required shift 'lsl #2'", "<STR_LIT>", ")", ";", "case", "Match_InvalidGPR64NoXZRshifted64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "register must be x0..x30 with required shift 'lsl #3'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32UXTW8", ":", "case", "Match_InvalidZPR32SXTW8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, (uxtw|sxtw)'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32UXTW16", ":", "case", "Match_InvalidZPR32SXTW16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, (uxtw|sxtw) #1'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32UXTW32", ":", "case", "Match_InvalidZPR32SXTW32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, (uxtw|sxtw) #2'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32UXTW64", ":", "case", "Match_InvalidZPR32SXTW64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, (uxtw|sxtw) #3'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64UXTW8", ":", "case", "Match_InvalidZPR64SXTW8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d, (uxtw|sxtw)'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64UXTW16", ":", "case", "Match_InvalidZPR64SXTW16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d, (lsl|uxtw|sxtw) #1'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64UXTW32", ":", "case", "Match_InvalidZPR64SXTW32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d, (lsl|uxtw|sxtw) #2'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64UXTW64", ":", "case", "Match_InvalidZPR64SXTW64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d, (lsl|uxtw|sxtw) #3'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32LSL8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32LSL16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, lsl #1'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32LSL32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, lsl #2'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR32LSL64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].s, lsl #3'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64LSL8", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64LSL16", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d, lsl #1'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64LSL32", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid shift/extend specified, expected 'z[0..31].d, lsl #2'", "<STR_LIT>", ")", ";", "case", "Match_InvalidZPR64LSL64", ":", "return", "Error", "(", "Loc", ",", "<STR_LIT>" ]

[ "}" ]

[ "void", "addRegOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "getReg", "(", ")", ")", ")", ";" ]

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

[ "assert", "(", "Top", ".", "isTop" ]

[ "<STR_LIT>", ")" ]

[ "(", "set", "(", "mem", ":", "QI", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>" ]

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

[ "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "NDS32_REQUIRED_CALLEE_SAVED_P", "(", "i" ]

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

[ "(", "define_reservation" ]

[ "bool", "FixFunctionBitcasts", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Function", "*", "Main", "=", "nullptr", ";", "CallInst", "*", "CallMain", "=", "nullptr", ";", "SmallVector", "<", "std", "::", "pair", "<", "Use", "*", ",", "Function", "*", ">", ",", "<NUM_LIT>", ">", "Uses", ";", "SmallPtrSet", "<", "Constant", "*", ",", "<NUM_LIT>", ">", "ConstantBCs", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "FindUses", "(", "&", "F", ",", "F", ",", "Uses", ",", "ConstantBCs", ")", ";", "if", "(", "!", "TemporaryWorkarounds", "&&", "!", "F", ".", "isDeclaration", "(", ")", "&&", "F", ".", "getName", "(", ")", "==", "<STR_LIT>", "main", "<STR_LIT>", ")", "{", "Main", "=", "&", "F", ";", "LLVMContext", "&", "C", "=", "M", ".", "getContext", "(", ")", ";", "Type", "*", "MainArgTys", "[", "]", "=", "{", "PointerType", "::", "get", "(", "Type", "::", "getInt8PtrTy", "(", "C", ")", ",", "<NUM_LIT>", ")", ",", "Type", "::", "getInt32Ty", "(", "C", ")", "}", ";", "FunctionType", "*", "MainTy", "=", "FunctionType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "C", ")", ",", "MainArgTys", ",", "false", ")", ";", "if", "(", "F", ".", "getFunctionType", "(", ")", "!=", "MainTy", ")", "{", "Value", "*", "Args", "[", "]", "=", "{", "UndefValue", "::", "get", "(", "MainArgTys", "[", "<NUM_LIT>", "]", ")", ",", "UndefValue", "::", "get", "(", "MainArgTys", "[", "<NUM_LIT>", "]", ")", "}", ";", "Value", "*", "Casted", "=", "ConstantExpr", "::", "getBitCast", "(", "Main", ",", "PointerType", "::", "get", "(", "MainTy", ",", "<NUM_LIT>", ")", ")", ";", "CallMain", "=", "CallInst", "::", "Create", "(", "Casted", ",", "Args", ",", "<STR_LIT>", "call_main", "<STR_LIT>", ")", ";", "Use", "*", "UseMain", "=", "&", "CallMain", "->", "getOperandUse", "(", "<NUM_LIT>", ")", ";", "Uses", ".", "push_back", "(", "std", "::", "make_pair", "(", "UseMain", ",", "&", "F", ")", ")", ";", "}", "}", "}", "DenseMap", "<", "std", "::", "pair", "<", "Function", "*", ",", "FunctionType", "*", ">", ",", "Function", "*", ">", "Wrappers", ";", "for", "(", "auto", "&", "UseFunc", ":", "Uses", ")", "{", "Use", "*", "U", "=", "UseFunc", ".", "first", ";", "Function", "*", "F", "=", "UseFunc", ".", "second", ";", "PointerType", "*", "PTy", "=", "cast", "<", "PointerType", ">", "(", "U", "->", "get", "(", ")", "->", "getType", "(", ")", ")", ";", "FunctionType", "*", "Ty", "=", "dyn_cast", "<", "FunctionType", ">", "(", "PTy", "->", "getElementType", "(", ")", ")", ";", "if", "(", "!", "Ty", ")", "continue", ";", "auto", "Pair", "=", "Wrappers", ".", "insert", "(", "std", "::", "make_pair", "(", "std", "::", "make_pair", "(", "F", ",", "Ty", ")", ",", "nullptr", ")", ")", ";", "if", "(", "Pair", ".", "second", ")", "Pair", ".", "first", "->", "second", "=", "CreateWrapper", "(", "F", ",", "Ty", ")", ";", "Function", "*", "Wrapper", "=", "Pair", ".", "first", "->", "second", ";", "if", "(", "!", "Wrapper", ")", "continue", ";", "if", "(", "isa", "<", "Constant", ">", "(", "U", "->", "get", "(", ")", ")", ")", "U", "->", "get", "(", ")", "->", "replaceAllUsesWith", "(", "Wrapper", ")", ";", "else", "U", "->", "set", "(", "Wrapper", ")", ";", "}", "if", "(", "CallMain", ")", "{", "Main", "->", "setName", "(", "<STR_LIT>", "__original_main", "<STR_LIT>", ")", ";", "Function", "*", "MainWrapper", "=", "cast", "<", "Function", ">", "(", "CallMain", "->", "getCalledValue", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "MainWrapper", "->", "setName", "(", "<STR_LIT>", "main", "<STR_LIT>", ")", ";", "MainWrapper", "->", "setLinkage", "(", "Main", "->", "getLinkage", "(", ")", ")", ";", "MainWrapper", "->", "setVisibility", "(", "Main", "->", "getVisibility", "(", ")", ")", ";", "Main", "->", "setLinkage", "(", "Function", "::", "PrivateLinkage", ")", ";", "Main", "->", "setVisibility", "(", "Function", "::", "DefaultVisibility", ")", ";", "delete", "CallMain", ";", "}", "return", "true", ";", "}" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

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

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

[ "<FIXS>", "machine_mode", "mode", ")", "<FIXE>" ]

[ "static", "booloffsettable_ok_by_alignment", "(", "rtx", "op", ",", "HOST_WIDE_INT", "offset", ",", "<BUGS>", "enum", "machine_mode", "mode", ")", "<BUGE>", "{", "tree", "decl", ",", "type", ";", "unsigned", "HOST_WIDE_INT", "dsize", ",", "dalign", ",", "lsb", ",", "mask", ";" ]

[ "[", "KryoUnitXY", "]", ">", "{" ]

[ "def", "KryoWrite_1cyc_XY_noRSV_77ln", ":", "SchedWriteRes", "<" ]

[ "}" ]

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

[ "}" ]

[ "bool", "ComplexPatternFuncMutatesDAG", "(", ")", "const", "override", "{", "return", "true", ";" ]

[ "if", "(", "i", "==", "e", ")", "continue", ";" ]

[ "for", "(", "auto", "&", "I2", ":", "*", "Inst", "->", "getParent", "(", ")", ")", "{", "if", "(", "dyn_cast", "<", "CallInst", ">", "(", "&", "I2", ")", ")", "return", "false", ";", "if", "(", "dyn_cast", "<", "LoadInst", ">", "(", "&", "I2", ")", "||", "dyn_cast", "<", "StoreInst", ">", "(", "&", "I2", ")", ")", "return", "false", ";", "if", "(", "&", "I2", "==", "Inst", ")", "break", ";", "}", "if", "(", "Inst", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "ZExt", "||", "Inst", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "SExt", ")", "{", "PassThroughInfo", "Info", "(", "&", "I", ",", "Inst", ",", "<NUM_LIT>", ")", ";", "Candidates", ".", "push_back", "(", "Info", ")", ";", "}", "else", "if", "(", "auto", "*", "GI", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "Inst", ")", ")", "{", "unsigned", "i", ",", "e", ";", "for", "(", "i", "=", "<NUM_LIT>", ",", "e", "=", "GI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Value", "*", "V", "=", "GI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "V", "==", "&", "I", ")", "break", ";", "}" ]

[ "getMask", "(", ")", ";" ]

[ "unsigned", "FromSz", "=", "LdVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "NumElems", "*", "FromSz", "*", "ToSz", ")", "&&", "<STR_LIT>", "Unexpected size for extending masked load", "<STR_LIT>", ")", ";", "unsigned", "SizeRatio", "=", "ToSz", "/", "FromSz", ";", "assert", "(", "SizeRatio", "*", "NumElems", "*", "FromSz", "==", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "EVT", "WideVecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "LdVT", ".", "getScalarType", "(", ")", ",", "NumElems", "*", "SizeRatio", ")", ";", "assert", "(", "WideVecVT", ".", "getSizeInBits", "(", ")", "==", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "SDValue", "WideSrc0", "=", "DAG", ".", "getBitcast", "(", "WideVecVT", ",", "Mld", "->", "getSrc0", "(", ")", ")", ";", "if", "(", "Mld", "->", "getSrc0", "(", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "UNDEF", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleVec", "(", "NumElems", "*", "SizeRatio", ",", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "i", "*", "SizeRatio", ";", "assert", "(", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "WideVecVT", ")", "&&", "<STR_LIT>", "WideVecVT should be legal", "<STR_LIT>", ")", ";", "WideSrc0", "=", "DAG", ".", "getVectorShuffle", "(", "WideVecVT", ",", "dl", ",", "WideSrc0", ",", "DAG", ".", "getUNDEF", "(", "WideVecVT", ")", ",", "&", "ShuffleVec", "[", "<NUM_LIT>", "]", ")", ";", "}", "SDValue", "NewMask", ";", "SDValue", "Mask", "=", "Mld", "->" ]

[ "setFeatureBits", "(", "Hexagon_MC", "::", "completeHVXFeatures", "(", "Features", ")", ")", ";" ]

[ "UseBSBScheduling", "=", "hasV60Ops", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "if", "(", "isTinyCore", "(", ")", ")", "{", "if", "(", "!", "EnableBSBSched", ".", "getPosition", "(", ")", ")", "UseBSBScheduling", "=", "false", ";", "}", "FeatureBitset", "Features", "=", "getFeatureBits", "(", ")", ";", "if", "(", "HexagonDisableDuplex", ")", "setFeatureBits", "(", "Features", ".", "reset", "(", "Hexagon", "::", "FeatureDuplex", ")", ")", ";" ]

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

[ "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "PC", "]", ";" ]

[ "def", "J4_cmpgtui_fp1_jump_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_14d27a", ",", "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", "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", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", "," ]

[ ";" ]

[ "SVECalleeSavedStackSize", "=", "Size" ]

[ ")", "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "CRIS_UNSPEC_SWAP_BITS", ")" ]

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

[ "(", "define_int_attr", "div_extend", "[", "(", "UNSPEC_DIVE", "\t", "<STR_LIT>", ")", "(", "UNSPEC_DIVEU", "\t" ]

[ "<NUM_LIT>", ";" ]

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

[ "}" ]

[ "void", "SILowerControlFlow", "::", "emitElseBreak", "(", "MachineInstr", "&", "MI", ")", "{", "emitIfBreak", "(", "MI", ")", ";" ]

[ "}" ]

[ "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";" ]

[ "E", ";" ]

[ "string", "DisableEncoding", "=" ]

[ "::", "f64", ",", "Res", ")", ";" ]

[ "if", "(", "HasR2", ")", "Res", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i64", ",", "DAG", ".", "getRegister", "(", "Mips", "::", "ZERO_64", ",", "MVT", "::", "i64", ")", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ",", "Const1", ",", "X", ")", ";", "else", "{", "SDValue", "SllX", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SHL", ",", "DL", ",", "MVT", "::", "i64", ",", "X", ",", "Const1", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i64", ",", "SllX", ",", "Const1", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT" ]

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

[ "class", "SIMDDup16FromElement", "<", "bit", "Q", ",", "string", "size", ",", "ValueType", "vectype", ",", "RegisterOperand", "vecreg", ">", ":", "SIMDDupFromElement", "<", "Q", ",", "size", ",", "<STR_LIT>", ",", "vectype", ",", "v8i16", ",", "vecreg", ",", "VectorIndexH", ",", "i64", ",", "ARM64duplane16", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "idx", ";" ]

[ ":" ]

[ "rtx", "plus0", ",", "plus1", ";", "enum", "rtx_code", "code", ";", "code", "=", "GET_CODE", "(", "address", ")", ";", "switch", "(", "code", ")", "{", "case", "POST_MODIFY", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "return", "<NUM_LIT>", ";", "case", "SYMBOL_REF", ":", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "case", "CONST", ":", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "case", "REG", ":", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "case", "PLUS" ]

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

[ "_", "_", "builtin_mve_vstrbq_p_sv4si", "(", "(", "_", "_", "builtin_neon_qi", "*", ")", "_", "_", "addr", ",", "_", "_", "value", ",", "_" ]

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

[ "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_divss_round", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_" ]

[ "<FIXS>", "if", "(", "X86FI", "->", "getStackPtrSaveMI", "(", ")", ")", "{", "Offset", "+=", "<NUM_LIT>", "*", "SlotSize", ";", "SmallString", "<NUM_LIT>", ">", "CfaExpr", ";", "CfaExpr", ".", "push_back", "(", "dwarf", "::", "DW_CFA_expression", ")", ";", "uint8_t", "buffer", "[", "<NUM_LIT>", "]", ";", "CfaExpr", ".", "append", "(", "buffer", ",", "buffer", "+", "encodeULEB128", "(", "DwarfReg", ",", "buffer", ")", ")", ";", "CfaExpr", ".", "push_back", "(", "<NUM_LIT>", ")", ";", "Register", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "const", "Register", "MachineFramePtr", "=", "STI", ".", "isTarget64BitILP32", "(", ")", "?", "Register", "(", "getX86SubSuperRegister", "(", "FramePtr", ",", "<NUM_LIT>", ")", ")", ":", "FramePtr", ";", "unsigned", "DwarfFramePtr", "=", "MRI", "->", "getDwarfRegNum", "(", "MachineFramePtr", ",", "true", ")", ";", "CfaExpr", ".", "push_back", "(", "(", "uint8_t", ")", "(", "dwarf", "::", "DW_OP_breg0", "+", "DwarfFramePtr", ")", ")", ";", "CfaExpr", ".", "append", "(", "buffer", ",", "buffer", "+", "encodeSLEB128", "(", "Offset", ",", "buffer", ")", ")", ";", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createEscape", "(", "nullptr", ",", "CfaExpr", ".", "str", "(", ")", ")", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "Offset", ")", ")", ";", "}", "<FIXE>" ]

[ "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "if", "(", "IsPrologue", ")", "{", "<BUGS>", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "Offset", ")", ")", ";", "<BUGE>", "}", "else", "{", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MCCFIInstruction", "::", "createRestore", "(", "nullptr", ",", "DwarfReg", ")", ")", ";", "}", "}", "}", "void", "X86FrameLowering", "::", "emitZeroCallUsedRegs", "(", "BitVector", "RegsToZero", "," ]

[ "}" ]

[ "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_broadcast_ss", "(", "float", "const", "*", "_", "_", "X", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_vbroadcastss", "(", "_", "_", "X", ")", ";" ]

[ "<FIXS>", "Register", "OrigDestReg", "=", "OrigMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "unsigned", "&", "SuperDestReg", ")", "const", "{", "auto", "*", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "<BUGS>", "unsigned", "OrigDestReg", "=", "OrigMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "SuperDestReg", "=", "getX86SubSuperRegister", "(", "OrigDestReg", ",", "<NUM_LIT>", ")", ";", "const", "auto", "SubRegIdx", "=", "TRI", "->", "getSubRegIndex", "(", "SuperDestReg", ",", "OrigDestReg", ")", ";" ]

[ "}" ]

[ "class", "BinaryRIL", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "SDPatternOperator", "operator", ",", "RegisterOperand", "cls", ",", "ImmOpWithPattern", "imm", ">", ":", "InstRILa", "<", "opcode", ",", "(", "outs", "cls", ":", "$", "R1", ")", ",", "(", "ins", "cls", ":", "$", "R1src", ",", "imm", ":", "$", "I2", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "(", "set", "cls", ":", "$", "R1", ",", "(", "operator", "cls", ":", "$", "R1src", ",", "imm", ":", "$", "I2", ")", ")", "]", ">", "{", "let", "Constraints", "=", "<STR_LIT>", ";", "let", "DisableEncoding", "=", "<STR_LIT>", ";" ]

[ ";" ]

[ "formatted_raw_ostream", "&", "getOStream", "(", ")", "{", "return", "OS" ]

[ "static", "void", "ix86_init_large_pic_reg", "(", "unsigned", "int", "tmp_regno", ")", "{", "rtx_code_label", "*", "label", ";", "rtx", "tmp_reg", ";", "gcc_assert", "(", "Pmode", "==", "DImode", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_PRESERVE_P", "(", "label", ")", "=", "<NUM_LIT>", ";", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "tmp_regno", ")", ";", "gcc_assert", "(", "REGNO", "(", "pic_offset_table_rtx", ")", "!=", "tmp_regno", ")", ";", "emit_insn", "(", "gen_set_rip_rex64", "(", "pic_offset_table_rtx", ",", "label", ")", ")", ";", "emit_insn", "(", "gen_set_got_offset_rex64", "(", "tmp_reg", ",", "label", ")", ")", ";", "emit_insn", "(", "ix86_gen_add3", "(", "pic_offset_table_rtx", ",", "pic_offset_table_rtx", ",", "tmp_reg", ")", ")", ";", "}" ]

[ "Initialize", "large", "model", "PIC", "register", "." ]

[ "}" ]

[ "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "Immediate", ";" ]

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

[ "Error", "(", "Loc", ",", "<STR_LIT>", "invalid code of hardware register: only 6-bit values are legal", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "else", "if", "(", "!", "isValidHwregOffset", "(", "Offset", ")", ")", "{", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid bit offset: only 5-bit values are legal", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "else", "if", "(", "!", "isValidHwregWidth", "(" ]

[ ")", ";" ]

[ "unsigned", "shift", ";", "for", "(", "shift", "=", "<NUM_LIT>", ";", "shift", "<", "<NUM_LIT>", ";", "shift", "+=", "<NUM_LIT>", ",", "type", "=", "TREE_TYPE", "(", "type", ")", ")", "{", "switch", "(", "TREE_CODE", "(", "type", ")", ")", "{", "case", "ERROR_MARK", ":", "return", "qualifiers", ";", "case", "ARRAY_TYPE", ":", "qualifiers", "|=", "(", "<NUM_LIT>", "<<", "shift", ")", ";", "break", ";", "case", "FUNCTION_TYPE", ":", "case", "METHOD_TYPE", ":", "qualifiers", "|=", "(", "<NUM_LIT>", "<<", "shift", ")", ";", "break", ";", "case", "POINTER_TYPE", ":", "case", "REFERENCE_TYPE", ":", "case", "OFFSET_TYPE", ":", "qualifiers", "|=", "(", "<NUM_LIT>", "<<", "shift", ")", ";", "break", ";", "case", "RECORD_TYPE", ":", "return", "(", "qualifiers", "|", "<NUM_LIT>", ")", ";", "case", "UNION_TYPE", ":", "case", "QUAL_UNION_TYPE", ":", "return", "(", "qualifiers", "|", "<NUM_LIT>" ]

[ "t", "=", "_", "_", "ev_mwhsmf", "(", "a", ",", "b", ")", ";" ]

[ "static", "inline", "_", "_", "ev64_opaque__", "_", "_", "internal_ev_mwhsmfanw", "(", "_", "_", "ev64_opaque__", "a", ",", "_", "_", "ev64_opaque__", "b", ")", "{", "_", "_", "ev64_opaque__", "t", ";" ]

[ "false", ";" ]

[ "default", ":", "return", "Error", "(", "IntTok", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "invalid stack index", "<STR_LIT>", ")", ";", "}", "if", "(", "getParser", "(", ")", ".", "Lex", "(", ")", ".", "isNot", "(", "AsmToken", "::", "RParen", ")", ")", "return", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "expected ')'", "<STR_LIT>", ")", ";", "EndLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "RegNo", "==", "<NUM_LIT>", "&&", "Tok", ".", "getString", "(", ")", ".", "size", "(", ")", "==", "<NUM_LIT>", "&&", "Tok", ".", "getString", "(", ")", ".", "startswith", "(", "<STR_LIT>", "db", "<STR_LIT>", ")", ")", "{", "switch", "(", "Tok", ".", "getString", "(", ")", "[", "<NUM_LIT>", "]", ")", "{", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR0", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR1", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR2", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR3", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR4", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR5", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR6", ";", "break", ";", "case", "'", "<NUM_LIT>", "'", ":", "RegNo", "=", "X86", "::", "DR7", ";", "break", ";", "}", "if", "(", "RegNo", "!=", "<NUM_LIT>", ")", "{", "EndLoc", "=", "Tok", ".", "getLoc", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "return" ]

[ "if", "(", "microblaze_expand_move", "(", "SImode", ",", "operands", ")", ")", "DONE" ]

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

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

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

[ "if", "(", "Kind", ".", "isCommon", "(", ")", ")", "{" ]

[ "TRACE", "(", "<STR_LIT>", "input section(", "<STR_LIT>", "<<", "GO", "->", "getSection", "(", ")", "<<", "<STR_LIT>", ") ", "<STR_LIT>", ")", ";", "TRACE", "(", "(", "GO", "->", "hasPrivateLinkage", "(", ")", "?", "<STR_LIT>", "private_linkage ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "GO", "->", "hasLocalLinkage", "(", ")", "?", "<STR_LIT>", "local_linkage ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "GO", "->", "hasInternalLinkage", "(", ")", "?", "<STR_LIT>", "internal ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "GO", "->", "hasExternalLinkage", "(", ")", "?", "<STR_LIT>", "external ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "GO", "->", "hasCommonLinkage", "(", ")", "?", "<STR_LIT>", "common_linkage ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "GO", "->", "hasCommonLinkage", "(", ")", "?", "<STR_LIT>", "common ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "Kind", ".", "isCommon", "(", ")", "?", "<STR_LIT>", "kind_common ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "Kind", ".", "isBSS", "(", ")", "?", "<STR_LIT>", "kind_bss ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", "<<", "(", "Kind", ".", "isBSSLocal", "(", ")", "?", "<STR_LIT>", "kind_bss_local ", "<STR_LIT>", ":", "<STR_LIT>", "<STR_LIT>", ")", ")", ";", "if", "(", "EmitLutInText", "&&", "GO", "->", "getName", "(", ")", ".", "startswith", "(", "<STR_LIT>", "switch.table", "<STR_LIT>", ")", ")", "{", "if", "(", "const", "Function", "*", "Fn", "=", "getLutUsedFunction", "(", "GO", ")", ")", "return", "selectSectionForLookupTable", "(", "GO", ",", "TM", ",", "Fn", ")", ";", "}", "if", "(", "isGlobalInSmallSection", "(", "GO", ",", "TM", ")", ")", "return", "selectSmallSectionForGlobal", "(", "GO", ",", "Kind", ",", "TM", ")", ";" ]

[ "static", "bool", "expand_vselect", "(", "rtx", "target", ",", "rtx", "op0", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ",", "bool", "testing_p", ")", "{", "unsigned", "int", "i", ";", "rtx", "x", ",", "save_vconcat", ";", "int", "icode", ";", "if", "(", "vselect_insn", "==", "NULL_RTX", ")", "init_vselect_insn", "(", ")", ";", "x", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "<NUM_LIT>", ")", ";", "PUT_NUM_ELEM", "(", "XVEC", "(", "x", ",", "<NUM_LIT>", ")", ",", "nelt", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nelt", ";", "++", "i", ")", "XVECEXP", "(", "x", ",", "<NUM_LIT>", ",", "i", ")", "=", "GEN_INT", "(", "perm", "[", "i", "]", ")", ";", "save_vconcat", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "<NUM_LIT>", ")", ";", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "<NUM_LIT>", ")", "=", "op0", ";", "PUT_MODE", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "GET_MODE", "(", "target", ")", ")", ";", "SET_DEST", "(", "PATTERN", "(", "vselect_insn", ")", ")", "=", "target", ";", "icode", "=", "recog_memoized", "(", "vselect_insn", ")", ";", "if", "(", "icode", ">=", "<NUM_LIT>", "&&", "!", "testing_p", ")", "emit_insn", "(", "copy_rtx", "(", "PATTERN", "(", "vselect_insn", ")", ")", ")", ";", "SET_DEST", "(", "PATTERN", "(", "vselect_insn", ")", ")", "=", "const0_rtx", ";", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "<NUM_LIT>", ")", "=", "save_vconcat", ";", "INSN_CODE", "(", "vselect_insn", ")", "=", "-", "<NUM_LIT>", ";", "return", "icode", ">=", "<NUM_LIT>", ";", "}" ]

[ "Construct", "(", "set", "target", "(", "vec_select", "op0", "(", "parallel", "perm", ")", ")", ")", "and", "return", "true", "if", "that", "'s", "a", "valid", "instruction", "in", "the", "active", "ISA", "." ]

[ "<FIXS>", "gimple_seq", "stmts", "=", "NULL", ";", "gimple_seq_add_stmt_without_update", "(", "&", "stmts", ",", "mem_ref_stmt", ")", ";", "<FIXE>" ]

[ "tree", "mem_ref_op", "=", "fold_build2", "(", "MEM_REF", ",", "access_type", ",", "arg1", ",", "zero", ")", ";", "gimple", "*", "mem_ref_stmt", "=", "gimple_build_assign", "(", "mem_ref_lhs", ",", "mem_ref_op", ")", ";", "<BUGS>", "gsi_insert_before", "(", "f", ".", "gsi", ",", "mem_ref_stmt", ",", "GSI_SAME_STMT", ")", ";", "<BUGE>", "int", "source_nelts", "=", "TYPE_VECTOR_SUBPARTS", "(", "access_type", ")", ".", "to_constant", "(", ")", ";", "vec_perm_builder", "sel", "(", "lhs_len", ",", "source_nelts", ",", "<NUM_LIT>", ")", ";" ]