Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

[ "RegisterAsmPrinter", "<", "SHUXIAsmPrinter", ">", "X", "(", "getTheSHUXI32Target", "(" ]

[ "return", "SIGN_EXTEND", ";" ]

[ "static", "int", "tilegx_mode_rep_extended", "(", "machine_mode", "mode", ",", "machine_mode", "mode_rep", ")", "{", "if", "(", "mode", "==", "SImode", "&&", "mode_rep", "==", "DImode", ")" ]

[ "(", "decl", ")", ")", "==", "NULL_TREE", ";" ]

[ "return", "lookup_attribute", "(", "<STR_LIT>", "naked", "<STR_LIT>", ",", "DECL_ATTRIBUTES" ]

[ "<FIXS>", "setOperationAction", "(", "ISD", "::", "TRAP", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "DEBUGTRAP", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "READCYCLECOUNTER", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "<BUGS>", "setOperationAction", "(", "ISD", "::", "TRAP", ",", "MVT", "::", "Other", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "DEBUGTRAP", ",", "MVT", "::", "Other", ",", "Legal", ")", ";", "<BUGE>", "setOperationAction", "(", "ISD", "::", "FMINNUM", ",", "MVT", "::", "f64", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FMAXNUM", ",", "MVT", "::", "f64", ",", "Legal", ")", ";" ]

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

[ "uint32_t", "value", "=", "(", "uint32_t", ")", "N", "-", ">", "getZExtValue", "(", ")", ";", "return", "(", "value", ">", "=", "<NUM_LIT>", "&", "&", "value", "<", "=", "<NUM_LIT>", ")", "|", "|", "value", "=", "=", "<NUM_LIT>", "|", "|", "value", "=", "=", "<NUM_LIT>", "|", "|", "value", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", ";", "def", "lda16f", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "addr", ",", "node", ":", "$", "offset", ")", ",", "(", "add", "node", ":", "$", "addr", ",", "(", "shl", "node", ":", "$", "offset", "," ]

[ ",", "TT", ")", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectivePPCCodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "Options", ")", ")", "{" ]

[ "PPCTargetMachine", "::", "PPCTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "getDataLayoutString", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "computeFSAdditions", "(", "FS", ",", "OL" ]

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

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

[ ")", ";" ]

[ "if", "(", "!", "ConstMask", ")", "return", "false", ";", "unsigned", "AddrSpace", "=", "cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getAddressSpace", "(", ")", ";", "PointerType", "*", "VecPtrTy", "=", "PointerType", "::", "get", "(", "Vec", "->", "getType", "(", ")", ",", "AddrSpace", ")", ";", "Value", "*", "PtrCast", "=", "IC", ".", "Builder", ".", "CreateBitCast", "(", "Ptr", ",", "VecPtrTy", ",", "<STR_LIT>", "castvec", "<STR_LIT>", ")", ";", "Constant", "*", "BoolMask", "=", "getNegativeIsTrueBoolVec", "(", "ConstMask" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "xor", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "xor", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "<BUGE>", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", ")" ]

[ ";" ]

[ "let", "isCall", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "R29", "]", ";", "let", "Defs", "=", "[", "PC", ",", "R31", "]", ";", "let", "hasSideEffects", "=", "<NUM_LIT>" ]

[ "<NUM_LIT>", ")", ",", "FI", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ";" ]

[ "assert", "(", "(", "Size", "==", "<NUM_LIT>", "||", "Size", "==", "<NUM_LIT>", "||", "Size", "==", "<NUM_LIT>", "||", "Size", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Unsupported size", "<STR_LIT>", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "const", "bool", "IsImmutable", "=", "!", "Flags", ".", "isByVal", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "IsImmutable", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "return", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", "," ]

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

[ "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isDoubleTy", "(", ")", "||", "!", "V", "->", "getType", "(", ")", "->", "isFloatTy", "(", ")", ")", "return", "false", ";", "unsigned", "Op", "=", "getRegForValue", "(", "V", ")", ";", "if", "(", "Op", "==", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "ResultReg", ")", ".", "addReg", "(", "Op", ")", ";", "UpdateValueMap", "(", "I", ",", "ResultReg", ")", ";" ]

[ "rtx", "gen_easy_altivec_constant", "(", "rtx", "op", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtx", "val", "=", "CONST_VECTOR_ELT", "(", "op", ",", "BYTES_BIG_ENDIAN", "?", "nunits", "-", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "unsigned", "step", "=", "nunits", "/", "<NUM_LIT>", ";", "unsigned", "copies", "=", "<NUM_LIT>", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "gen_rtx_VEC_DUPLICATE", "(", "V4SImode", ",", "gen_lowpart", "(", "SImode", ",", "val", ")", ")", ";", "if", "(", "step", "==", "<NUM_LIT>", ")", "copies", "<<=", "<NUM_LIT>", ";", "else", "step", ">>=", "<NUM_LIT>", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "gen_rtx_VEC_DUPLICATE", "(", "V8HImode", ",", "gen_lowpart", "(", "HImode", ",", "val", ")", ")", ";", "if", "(", "step", "==", "<NUM_LIT>", ")", "copies", "<<=", "<NUM_LIT>", ";", "else", "step", ">>=", "<NUM_LIT>", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "gen_rtx_VEC_DUPLICATE", "(", "V16QImode", ",", "gen_lowpart", "(", "QImode", ",", "val", ")", ")", ";", "gcc_unreachable", "(", ")", ";", "}" ]

[ "Generate", "a", "VEC_DUPLICATE", "representing", "a", "vspltis", "[", "bhw", "]", "instruction", "whose", "result", "is", "OP", ".", "Abort", "if", "it", "is", "not", "possible", "." ]

[ "}", "while", "(", "I", "!=", "E", "&&", "I", "->", "getParent", "(", ")", "==", "&", "UseMI", ")", ";" ]

[ "case", "AMDGPU", "::", "PHI", ":", "case", "AMDGPU", "::", "INSERT_SUBREG", ":", "break", ";", "default", ":", "OpNo", "=", "I", ".", "getOperandNo", "(", ")", ";", "break", ";", "}", "if", "(", "!", "RI", ".", "hasVectorRegisters", "(", "getOpRegClass", "(", "UseMI", ",", "OpNo", ")", ")", ")", "{", "Worklist", ".", "insert", "(", "&", "UseMI", ")", ";", "do", "{", "++", "I", ";" ]

[ ")", ";" ]

[ "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_fnmls_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_fsub", ":", "return", "instCombineSVEVectorFSub", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_fsub_u", ":", "return", "instCombineSVEVectorFSubU", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_add", ":", "return", "instCombineSVEVectorAdd", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_add_u", ":", "return", "instCombineSVEVectorFuseMulAddSub", "<", "Intrinsic", "::", "aarch64_sve_mul_u", ",", "Intrinsic", "::", "aarch64_sve_mla_u", ">", "(", "IC", ",", "II", ",", "true", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mla", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_mla_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mls", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_mls_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul", ":", "if", "(", "auto", "II_U", "=", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_mul_u", ")", ")", "return", "II_U", ";", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_mul_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_mul_u", ":", "return", "instCombineSVEVectorMul", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_mul_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_sabd", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_sabd_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_smax", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_smax_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_smin", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_smin_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_smulh", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_smulh_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_sub", ":", "return", "instCombineSVEVectorSub", "(", "IC", ",", "II", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_sub_u", ":", "return", "instCombineSVEVectorFuseMulAddSub", "<", "Intrinsic", "::", "aarch64_sve_mul_u", ",", "Intrinsic", "::", "aarch64_sve_mls_u", ">", "(", "IC", ",", "II", ",", "true", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_uabd", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_uabd_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_umax", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_umax_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_umin", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_umin_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_umulh", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_umulh_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_asr", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_asr_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lsl", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_lsl_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_lsr", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_lsr_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_and", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_and_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_bic", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_bic_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_eor", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_eor_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_orr", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_orr_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_sqsub", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_sqsub_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_uqsub", ":", "return", "instCombineSVEAllOrNoActive", "(", "IC", ",", "II", ",", "Intrinsic", "::", "aarch64_sve_uqsub_u", ")", ";", "case", "Intrinsic", "::", "aarch64_sve_tbl", ":", "return", "instCombineSVETBL", "(", "IC", ",", "II" ]

[ "}" ]

[ "class", "AuthReturn", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "bits", "<", "<NUM_LIT>", ">", "M", ",", "string", "asm", ">", ":", "AuthBase", "<", "M", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "asm", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "case", "X86", "::", "R13", ":", "return", "X86", "::", "R13D", ";" ]

[ "case", "X86", "::", "R8", ":", "return", "X86", "::", "R8D", ";", "case", "X86", "::", "R9", ":", "return", "X86", "::", "R9D", ";", "case", "X86", "::", "R10", ":", "return", "X86", "::", "R10D", ";", "case", "X86", "::", "R11", ":", "return", "X86", "::", "R11D", ";", "case", "X86", "::", "R12", ":", "return", "X86", "::", "R12D", ";" ]

[ "bool", "SystemZTDCPass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", "F", ")", ".", "hasSoftFloat", "(", ")", ")", "return", "false", ";", "ConvertedInsts", ".", "clear", "(", ")", ";", "LogicOpsWorklist", ".", "clear", "(", ")", ";", "PossibleJunk", ".", "clear", "(", ")", ";", "for", "(", "auto", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "Instruction", "::", "FCmp", ")", "convertFCmp", "(", "cast", "<", "CmpInst", ">", "(", "I", ")", ")", ";", "else", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "Instruction", "::", "ICmp", ")", "convertICmp", "(", "cast", "<", "CmpInst", ">", "(", "I", ")", ")", ";", "}", "if", "(", "ConvertedInsts", ".", "empty", "(", ")", ")", "return", "false", ";", "while", "(", "!", "LogicOpsWorklist", ".", "empty", "(", ")", ")", "{", "BinaryOperator", "*", "Op", "=", "LogicOpsWorklist", ".", "back", "(", ")", ";", "LogicOpsWorklist", ".", "pop_back", "(", ")", ";", "if", "(", "ConvertedInsts", ".", "count", "(", "dyn_cast", "<", "Instruction", ">", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "&&", "ConvertedInsts", ".", "count", "(", "dyn_cast", "<", "Instruction", ">", "(", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "&&", "!", "ConvertedInsts", ".", "count", "(", "Op", ")", ")", "convertLogicOp", "(", "*", "Op", ")", ";", "}", "Module", "&", "M", "=", "*", "F", ".", "getParent", "(", ")", ";", "auto", "&", "Ctx", "=", "M", ".", "getContext", "(", ")", ";", "Value", "*", "Zero32", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ",", "<NUM_LIT>", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "&", "It", ":", "reverse", "(", "ConvertedInsts", ")", ")", "{", "Instruction", "*", "I", "=", "It", ".", "first", ";", "Value", "*", "V", ";", "int", "Mask", ";", "bool", "Worthy", ";", "std", "::", "tie", "(", "V", ",", "Mask", ",", "Worthy", ")", "=", "It", ".", "second", ";", "if", "(", "!", "I", "->", "user_empty", "(", ")", ")", "{", "if", "(", "!", "Worthy", ")", "continue", ";", "Function", "*", "TDCFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "s390_tdc", ",", "V", "->", "getType", "(", ")", ")", ";", "IRBuilder", "<", ">", "IRB", "(", "I", ")", ";", "Value", "*", "MaskVal", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt64Ty", "(", "Ctx", ")", ",", "Mask", ")", ";", "Instruction", "*", "TDC", "=", "IRB", ".", "CreateCall", "(", "TDCFunc", ",", "{", "V", ",", "MaskVal", "}", ")", ";", "Value", "*", "ICmp", "=", "IRB", ".", "CreateICmp", "(", "CmpInst", "::", "ICMP_NE", ",", "TDC", ",", "Zero32", ")", ";", "I", "->", "replaceAllUsesWith", "(", "ICmp", ")", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "!", "MadeChange", ")", "return", "false", ";", "for", "(", "auto", "*", "I", ":", "PossibleJunk", ")", "if", "(", "I", "->", "user_empty", "(", ")", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "<FIXS>", "mips_expand_vi_general", "(", "machine_mode", "vmode", ",", "machine_mode", "imode", ",", "<FIXE>" ]

[ "static", "void", "<BUGS>", "mips_expand_vi_general", "(", "enum", "machine_mode", "vmode", ",", "enum", "machine_mode", "imode", ",", "<BUGE>", "unsigned", "nelt", ",", "unsigned", "nvar", ",", "rtx", "target", ",", "rtx", "vals", ")", "{", "rtx", "mem", "=", "assign_stack_temp", "(", "vmode", ",", "GET_MODE_SIZE", "(", "vmode", ")", ")", ";" ]

[ "void", "visium_profile_hook", "(", "void", ")", "{", "visium_frame_needed", "=", "true", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "mcount", "<STR_LIT>", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "<NUM_LIT>", ")", ";", "}" ]

[ "Profiling", "support", ".", "Just", "a", "call", "to", "MCOUNT", "is", "needed", ".", "No", "labelled", "counter", "location", "is", "involved", ".", "Proper", "support", "for", "__builtin_return_address", "is", "also", "required", ",", "which", "is", "fairly", "straightforward", "provided", "a", "frame", "gets", "created", "." ]

[ "<FIXS>", "void", "AMDGPUInstPrinter", "::", "printPackedModifier", "(", "const", "MCInst", "*", "MI", ",", "StringRef", "Name", ",", "unsigned", "Mod", ",", "raw_ostream", "&", "O", ")", "{", "<FIXE>" ]

[ "return", "false", ";", "}", "return", "true", ";", "}", "<BUGS>", "static", "void", "printPackedModifier", "(", "const", "MCInst", "*", "MI", ",", "StringRef", "Name", ",", "unsigned", "Mod", ",", "raw_ostream", "&", "O", ")", "{", "<BUGE>", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "NumOps", "=", "<NUM_LIT>", ";", "int", "Ops", "[", "<NUM_LIT>", "]", ";" ]

[ ";" ]

[ "assert", "(", "IsUnscaled", "==", "TII", "->", "isUnscaledLdSt", "(", "*", "StoreI", ")", "&&", "<STR_LIT>", "Unsupported ld/st match", "<STR_LIT>", ")", ";", "assert", "(", "LoadSize", "<=", "StoreSize", "&&", "<STR_LIT>", "Invalid load size", "<STR_LIT>", ")", ";", "int", "UnscaledLdOffset", "=", "IsUnscaled", "?", "getLdStOffsetOp", "(", "*", "LoadI", ")", ".", "getImm", "(", ")", ":", "getLdStOffsetOp", "(", "*", "LoadI", ")", ".", "getImm", "(", ")", "*", "LoadSize", ";", "int", "UnscaledStOffset", "=", "IsUnscaled", "?", "getLdStOffsetOp", "(", "*", "StoreI", ")", ".", "getImm", "(", ")", ":", "getLdStOffsetOp", "(", "*", "StoreI", ")", ".", "getImm", "(", ")", "*", "StoreSize", ";", "int", "Width", "=", "LoadSize", "*", "<NUM_LIT>", ";", "int", "Immr", "=", "<NUM_LIT>", "*", "(", "UnscaledLdOffset", "-", "UnscaledStOffset", ")", ";", "int", "Imms", "=", "Immr", "+", "Width", "-", "<NUM_LIT>", ";", "unsigned", "DestReg", "=", "IsStoreXReg", "?", "TRI", "->", "getMatchingSuperReg", "(", "LdRt", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ":", "LdRt", ";", "assert", "(", "(", "UnscaledLdOffset", ">=", "UnscaledStOffset", "&&", "(", "UnscaledLdOffset", "+", "LoadSize", ")", "<=", "UnscaledStOffset", "+", "StoreSize", ")", "&&", "<STR_LIT>", "Invalid offset", "<STR_LIT>", ")", ";", "Immr", "=", "<NUM_LIT>", "*", "(", "UnscaledLdOffset", "-", "UnscaledStOffset", ")", ";", "Imms", "=", "Immr", "+", "Width", "-", "<NUM_LIT>", ";", "if", "(", "UnscaledLdOffset", "==", "UnscaledStOffset", ")", "{", "uint32_t", "AndMaskEncoded", "=", "(", "(", "IsStoreXReg", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", "|", "(", "(", "Immr", ")", "<<", "<NUM_LIT>", ")", "|", "(", "(", "Imms", ")", "<<", "<NUM_LIT>", ")", ";", "BitExtMI", "=", "BuildMI", "(", "*", "LoadI", "->", "getParent", "(", ")", ",", "LoadI", ",", "LoadI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "IsStoreXReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "add", "(", "StMO", ")", ".", "addImm", "(", "AndMaskEncoded", ")", ";", "}", "else", "{", "BitExtMI", "=", "BuildMI", "(", "*", "LoadI", "->", "getParent", "(", ")", ",", "LoadI", ",", "LoadI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "IsStoreXReg", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "add", "(", "StMO", ")", ".", "addImm", "(", "Immr", ")", ".", "addImm", "(", "Imms", ")", ";", "}", "}", "for", "(", "MachineInstr", "&", "MI", ":", "make_range", "(", "StoreI", "->", "getIterator", "(", ")", ",", "BitExtMI", "->", "getIterator", "(", ")", ")", ")", "if", "(", "MI", ".", "killsRegister", "(", "StRt", ",", "TRI", ")", ")", "{", "MI", ".", "clearRegisterKills", "(", "StRt", ",", "TRI", ")", ";", "break", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Promoting load by replacing :\\n ", "<STR_LIT>", ")", ";", "DEBUG", "(", "StoreI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ")", ";", "DEBUG", "(", "LoadI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " with instructions:\\n ", "<STR_LIT>", ")", ";", "DEBUG", "(", "StoreI", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ")", ";", "DEBUG", "(", "(", "BitExtMI", ")", "->", "print", "(", "dbgs", "(", ")", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "LoadI", "->", "eraseFromParent", "(", ")", ";", "return", "NextI" ]

[ "static", "bool", "ix86_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "type", ",", "decl_or_type", ";", "rtx", "a", ",", "b", ";", "bool", "bind_global", "=", "decl", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ";", "if", "(", "ix86_function_naked", "(", "current_function_decl", ")", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "no_caller_saved_registers", ")", "return", "false", ";", "if", "(", "!", "TARGET_MACHO", "&&", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "flag_plt", "&&", "bind_global", ")", "return", "false", ";", "if", "(", "ix86_minimum_incoming_stack_boundary", "(", "true", ")", "<", "PREFERRED_STACK_BOUNDARY", ")", "return", "false", ";", "if", "(", "decl", ")", "{", "decl_or_type", "=", "decl", ";", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "}", "else", "{", "type", "=", "CALL_EXPR_FN", "(", "exp", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "decl_or_type", "=", "type", ";", "}", "if", "(", "(", "OUTGOING_REG_PARM_STACK_SPACE", "(", "type", ")", "!=", "OUTGOING_REG_PARM_STACK_SPACE", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "||", "(", "REG_PARM_STACK_SPACE", "(", "decl_or_type", ")", "!=", "REG_PARM_STACK_SPACE", "(", "current_function_decl", ")", ")", ")", "{", "maybe_complain_about_tail_call", "(", "exp", ",", "<STR_LIT>", "inconsistent size of stack space", "<STR_LIT>", "<STR_LIT>", " allocated for arguments which are", "<STR_LIT>", "<STR_LIT>", " passed in registers", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "a", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "decl_or_type", ",", "false", ")", ";", "b", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";", "if", "(", "STACK_REG_P", "(", "a", ")", "||", "STACK_REG_P", "(", "b", ")", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "}", "else", "if", "(", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", ";", "else", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "cfun", "->", "machine", "->", "call_abi", "==", "MS_ABI", "&&", "ix86_function_type_abi", "(", "type", ")", "==", "SYSV_ABI", ")", "return", "false", ";", "}", "else", "{", "if", "(", "!", "decl", "||", "(", "bind_global", "&&", "flag_pic", "&&", "!", "flag_plt", ")", "||", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "DECL_DLLIMPORT_P", "(", "decl", ")", ")", "||", "flag_force_indirect_call", ")", "{", "if", "(", "ix86_function_regparm", "(", "type", ",", "decl", ")", ">=", "<NUM_LIT>", "&&", "!", "cfun", "->", "machine", "->", "arg_reg_available", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "<FIXS>", "initializeARMDAGToDAGISelLegacyPass", "(", "Registry", ")", ";", "<FIXE>" ]

[ "initializeARMSLSHardeningPass", "(", "Registry", ")", ";", "initializeMVELaneInterleavingPass", "(", "Registry", ")", ";", "initializeARMFixCortexA57AES1742098Pass", "(", "Registry", ")", ";", "<BUGS>", "initializeARMDAGToDAGISelPass", "(", "Registry", ")", ";", "<BUGE>", "}", "static", "std", "::", "unique_ptr", "TargetLoweringObjectFile", ">", "createTLOF", "(", "const", "Triple", "&", "TT", ")", "{" ]

[ "<FIXS>", "def", "SLBIEG", ":", "XForm_26", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "gprc", ":", "$", "RST", ",", "gprc", ":", "$", "RB", ")", ",", "<STR_LIT>", ",", "IIC_SprSLBIEG", ",", "[", "]", ">", ";", "<FIXE>" ]

[ "}", "<BUGS>", "def", "SLBIEG", ":", "XForm_26", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", "gprc", ":", "$", "RS", ",", "gprc", ":", "$", "RB", ")", ",", "<STR_LIT>", ",", "IIC_SprSLBIEG", ",", "[", "]", ">", ";", "<BUGE>", "def", "SLBSYNC", ":", "XForm_0", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "IIC_SprSLBSYNC", ",", "[", "]", ">", ";" ]

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

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

[ "F", ")", ".", "genExecuteOnly", "(", ")", "&&", "SK", ".", "isText", "(", ")", ")", "return", "true", ";" ]

[ "static", "bool", "isExecuteOnlyFunction", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "SK", ",", "const", "TargetMachine", "&", "TM", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "dyn_cast", "<", "Function", ">", "(", "GO", ")", ")", "if", "(", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "*" ]

[ "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", ")", "]" ]

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V2HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "minus", ":", "HI", "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "RT", ";", "bits", "<", "<NUM_LIT>", ">", "RB", ";", "let", "CRD", "=", "RT", ";", "let", "CRA", "=", "<NUM_LIT>", ";", "let", "CRB", "=", "RB", ";" ]

[ "<FIXS>", "MCE", ".", "startFunctionStub", "(", "F", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "return", "MCE", ".", "finishFunctionStub", "(", "F", ")", ";", "<FIXE>" ]

[ "MCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitByte", "(", "<NUM_LIT>", "|", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "|", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", ";", "#", "else", "<BUGS>", "MCE", ".", "startFunctionStub", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "MCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "MCE", ".", "emitWordLE", "(", "(", "intptr_t", ")", "Fn", "-", "MCE", ".", "getCurrentPCValue", "(", ")", "-", "<NUM_LIT>", ")", ";", "#", "endifMCE", ".", "emitByte", "(", "<NUM_LIT>", ")", ";", "<BUGS>", "return", "MCE", ".", "finishFunctionStub", "(", "<NUM_LIT>", ")", ";", "<BUGE>", "}" ]

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

[ "def", "SW", "{", "bits", "<", "<NUM_LIT>", ">", "ST", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "SET", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "MSB", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "FORCE_SIGN0", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "INC_0", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "INC_1", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "INC_2", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "INC_4", "=", "<NUM_LIT>", ";" ]

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

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

[ "}" ]

[ "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "<NUM_LIT>", ";", "local_cum", "=", "*", "pcum", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "csky_function_arg_advance", "(", "local_cum_v", ",", "arg", ")", ";", "regs_to_push", "=", "CSKY_NPARM_REGS", "-", "local_cum", ".", "reg", ";", "if", "(", "regs_to_push", ")", "*", "pretend_size", "=", "regs_to_push", "*", "UNITS_PER_WORD", ";" ]

[ "}" ]

[ "void", "AArch64InstPrinter", "::", "printZPRasFPR", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "unsigned", "Base", ";", "switch", "(", "Width", ")", "{", "case", "<NUM_LIT>", ":", "Base", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "Base", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "Base", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "Base", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "Base", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported width", "<STR_LIT>", ")", ";", "}", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ";", "O", "<<", "getRegisterName", "(", "Reg", "-", "<STR_LIT>", "::", "<STR_LIT>", "+", "Base", ")", ";" ]

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

[ "def", "MipsVSMin", ":", "SDNode", "<", "<STR_LIT>", ",", "SDTIntBinOp", ",", "[", "SDNPCommutative" ]

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

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

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

[ "SDValue", "And0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "And1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "SMPos0", ",", "SMSize0", ",", "SMPos1", ",", "SMSize1", ";", "ConstantSDNode", "*", "CN", ",", "*", "CN1", ";", "if", "(", "And0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "And0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "||", "!", "isShiftedMask_64", "(", "~", "CN", "->", "getSExtValue", "(", ")", ",", "SMPos0", ",", "SMSize0", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "And1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "And1", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", ")", "{", "if", "(", "!", "(", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "And1", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "||", "!", "isShiftedMask_64", "(", "CN", "->", "getZExtValue", "(", ")", ",", "SMPos1", ",", "SMSize1", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "SMPos0", "!=", "SMPos1", "||", "SMSize0", "!=", "SMSize1", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Shl", "=", "And1", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "(", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Shl", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Shamt", "=", "CN", "->", "getZExtValue", "(", ")", ";", "EVT", "ValTy", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "if", "(", "(", "Shamt", "!=", "SMPos0", ")", "||", "(", "SMPos0", "+", "SMSize0", ">", "ValTy", ".", "getSizeInBits", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "ValTy", ",", "Shl", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "SMPos0", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "SMSize0", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "And0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "{", "if", "(", "~", "CN", "->", "getSExtValue", "(", ")", "==", "(", "(", "(", "(", "int64_t", ")", "<NUM_LIT>", "<<", "SMSize0", ")", "-", "<NUM_LIT>", ")", "<<", "SMPos0", ")", "&&", "(", "(", "SMSize0", "+", "SMPos0", "<=", "<NUM_LIT>", "&&", "Subtarget", ".", "hasMips64r2", "(", ")", ")", "||", "(", "SMSize0", "+", "SMPos0", "<=", "<NUM_LIT>", ")", ")", ")", "{", "bool", "isConstCase", "=", "And1", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", ";", "if", "(", "And1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", ")", "{", "if", "(", "!", "(", "CN1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "And1", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", ")", "return", "SDValue", "(", ")", ";", "}", "else", "{", "if", "(", "!", "(", "CN1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")" ]

[ "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_cvtpd_epu32", "(", "_", "_", "m256i", "_", "_", "W", ",", "_", "_" ]

[ ".", "copyImplicitOps", "(", "*", "MI", ")", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "callee-saved register of unexpected class", "<STR_LIT>", ")", ";", "}", "if", "(", "(", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "Reg", ")", ")", "&&", "!", "(", "hasFP", "(", "MF", ")", "&&", "Reg", "==", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ")", ")", "CopyRegs", ".", "insert", "(", "Reg", ")", ";", "}", "auto", "Terminator", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "Terminator", "!=", "MBB", ".", "end", "(", ")", "&&", "Terminator", "->", "getOpcode", "(", ")", "==", "ARM", "::", "tBX_RET", ")", "{", "CopyRegs", ".", "insert", "(", "ARM", "::", "R0", ")", ";", "CopyRegs", ".", "insert", "(", "ARM", "::", "R1", ")", ";", "CopyRegs", ".", "insert", "(", "ARM", "::", "R2", ")", ";", "CopyRegs", ".", "insert", "(", "ARM", "::", "R3", ")", ";", "for", "(", "auto", "Op", ":", "Terminator", "->", "implicit_operands", "(", ")", ")", "{", "if", "(", "Op", ".", "isReg", "(", ")", ")", "CopyRegs", ".", "erase", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", "}", "static", "const", "unsigned", "AllCopyRegs", "[", "]", "=", "{", "ARM", "::", "R0", ",", "ARM", "::", "R1", ",", "ARM", "::", "R2", ",", "ARM", "::", "R3", ",", "ARM", "::", "R4", ",", "ARM", "::", "R5", ",", "ARM", "::", "R6", ",", "ARM", "::", "R7", "}", ";", "static", "const", "unsigned", "AllHighRegs", "[", "]", "=", "{", "ARM", "::", "R8", ",", "ARM", "::", "R9", ",", "ARM", "::", "R10", ",", "ARM", "::", "R11", "}", ";", "const", "unsigned", "*", "AllCopyRegsEnd", "=", "std", "::", "end", "(", "AllCopyRegs", ")", ";", "const", "unsigned", "*", "AllHighRegsEnd", "=", "std", "::", "end", "(", "AllHighRegs", ")", ";", "auto", "HiRegToRestore", "=", "findNextOrderedReg", "(", "std", "::", "begin", "(", "AllHighRegs", ")", ",", "HiRegsToRestore", ",", "AllHighRegsEnd", ")", ";", "while", "(", "HiRegToRestore", "!=", "AllHighRegsEnd", ")", "{", "assert", "(", "!", "CopyRegs", ".", "empty", "(", ")", ")", ";", "auto", "CopyReg", "=", "findNextOrderedReg", "(", "std", "::", "begin", "(", "AllCopyRegs", ")", ",", "CopyRegs", ",", "AllCopyRegsEnd", ")", ";", "MachineInstrBuilder", "PopMIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "PopMIB", ")", ";", "while", "(", "HiRegToRestore", "!=", "AllHighRegsEnd", "&&", "CopyReg", "!=", "AllCopyRegsEnd", ")", "{", "PopMIB", ".", "addReg", "(", "*", "CopyReg", ",", "RegState", "::", "Define", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ";", "MIB", ".", "addReg", "(", "*", "HiRegToRestore", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "*", "CopyReg", ",", "RegState", "::", "Kill", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "CopyReg", "=", "findNextOrderedReg", "(", "++", "CopyReg", ",", "CopyRegs", ",", "AllCopyRegsEnd", ")", ";", "HiRegToRestore", "=", "findNextOrderedReg", "(", "++", "HiRegToRestore", ",", "HiRegsToRestore", ",", "AllHighRegsEnd", ")", ";", "}", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPOP", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "bool", "NeedsPop", "=", "false", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "<NUM_LIT>", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "<NUM_LIT>", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "(", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "Reg", ")", "||", "Reg", "==", "ARM", "::", "LR", ")", ")", "continue", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "if", "(", "MBB", ".", "succ_empty", "(", ")", ")", "{", "if", "(", "isVarArg", ")", "continue", ";", "if", "(", "!", "STI", ".", "hasV5TOps", "(", ")", ")", "continue", ";", "Reg", "=", "ARM", "::", "PC", ";", "(", "*", "MIB", ")", ".", "setDesc", "(", "TII", ".", "get", "(", "ARM", "::", "tPOP_RET", ")", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "MIB" ]

[ "<FIXS>", "poly_int64", "offset", ";", "addr", "=", "strip_offset_and_salt", "(", "addr", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", ")", "<FIXE>" ]

[ "tls_symbolic_operand_type", "(", "rtx", "addr", ")", "{", "enum", "tls_model", "tls_kind", "=", "TLS_MODEL_NONE", ";", "<BUGS>", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "{", "poly_int64", "addend", ";", "rtx", "sym", "=", "strip_offset", "(", "addr", ",", "&", "addend", ")", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "SYMBOL_REF", ")", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "sym", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", ")", "<BUGE>", "tls_kind", "=", "SYMBOL_REF_TLS_MODEL", "(", "addr", ")", ";", "return", "tls_kind", ";" ]

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

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

[ "if", "(", "!", "Subtarget", "->", "hasMips32r2", "(", ")", ")", "{" ]

[ "}", "setOperationAction", "(", "ISD", "::", "ADD", ",", "MVT", "::", "i32", ",", "Custom", ")", ";", "if", "(", "Subtarget", "->", "isGP64bit", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "ADD", ",", "MVT", "::", "i64", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BR_CC", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SELECT_CC", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND_INREG", ",", "MVT", "::", "i1", ",", "Expand", ")", ";", "if", "(", "Subtarget", "->", "hasCnMips", "(", ")", ")", "{", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i32", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i64", ",", "Legal", ")", ";", "}", "else", "{", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ_ZERO_UNDEF", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTTZ_ZERO_UNDEF", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ_ZERO_UNDEF", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ_ZERO_UNDEF", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "DYNAMIC_STACKALLOC", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "DYNAMIC_STACKALLOC", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", "->", "hasMips32r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "if", "(", "!", "Subtarget", "->", "hasMips64r2", "(", ")", ")", "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSIN", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FCOS", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSINCOS", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FSINCOS", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOWI", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FPOW", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG2", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FLOG10", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FEXP", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FMA", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "FREM", ",", "MVT", "::", "f64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "EH_RETURN", ",", "MVT", "::", "Other", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VAARG", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VACOPY", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "VAEND", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKSAVE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "STACKRESTORE", ",", "MVT", "::", "Other", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_LOAD", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_LOAD", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_STORE", ",", "MVT", "::", "i32", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "ATOMIC_STORE", ",", "MVT", "::", "i64", ",", "Expand", ")", ";", "setInsertFencesForAtomic", "(", "true", ")", ";" ]

[ "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "<STR_LIT>", "ARM Machine Code Emitter", "<STR_LIT>", ";", "}" ]

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

[ ";" ]

[ "PrintPICBaseSymbol", "(", "O", ")", ";", "O", "<<", "'", "\\n", "'", ";", "PrintPICBaseSymbol", "(", "O", ")" ]

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

[ "case", "ARM", "::", "FK_VFPV4", ":", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_FPV4_SP_D16", ":", "case", "ARM", "::", "FK_VFPV4_D16", ":", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_FP_ARMV8", ":", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_FPV5_SP_D16", ":", "case", "ARM", "::", "FK_FPV5_D16", ":", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_NEON", ":", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "break", ";", "case", "ARM", "::", "FK_NEON_FP16", ":", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "false", ")", ";", "S", ".", "setAttributeItem", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::" ]

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

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

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "ior", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "<BUGE>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REG", ")", ")", "]" ]

[ "(", "and", ":", "QI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "<NUM_LIT>", ")", ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "SI", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "and", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "subreg", ":", "SI", "(", "lshiftrt", ":", "DI", "(", "zero_extend", ":", "DI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "minus", ":", "QI", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "return", "AMDGPU", "::", "IsaInfo", "::", "getMinFlatWorkGroupSize" ]

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

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "pc", ")", "(", "if_then_else", "(", "eq", "(", "reg", ":", "CC", "<NUM_LIT>", ")" ]

[ "(", "fneg", "f64", ":", "$", "XTi", ")", ")", ")", "]", ">", ",", "RegConstraint", "<", "<STR_LIT>", ">", ",", "NoEncode", "<", "<STR_LIT>", ">", ",", "AltVSXFMARel", ";" ]

[ "def", "XSMSUBADP", ":", "XX3Form", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "vsfrc", ":", "$", "XT", ")", ",", "(", "ins", "vsfrc", ":", "$", "XTi", ",", "vsfrc", ":", "$", "XA", ",", "vsfrc", ":", "$", "XB", ")", ",", "<STR_LIT>", ",", "IIC_VecFP", ",", "[", "(", "set", "f64", ":", "$", "XT", ",", "(", "fma", "f64", ":", "$", "XA", ",", "f64", ":", "$", "XB", "," ]

[ "<NUM_LIT>", ";" ]

[ "MachineInstr", "*", "CCMI", "=", "MRI", ".", "getVRegDef", "(", "CondReg", ")", ";", "if", "(", "CCMI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_TRUNC", ")", "CCMI", "=", "MRI", ".", "getVRegDef", "(", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "CCMI", "->", "getOpcode", "(", ")", "!=", "TargetOpcode", "::", "G_ICMP", ")", "return", "false", ";", "Register", "LHS", "=", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "Register", "RHS", "=", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "getConstantVRegVal", "(", "RHS", ",", "MRI", ")", ")", "std", "::", "swap", "(", "RHS", ",", "LHS", ")", ";", "const", "auto", "RHSImm", "=", "getConstantVRegVal", "(", "RHS", ",", "MRI", ")", ";", "if", "(", "!", "RHSImm", "||", "*", "RHSImm", "!=", "<NUM_LIT>", ")", "return", "false", ";", "const", "RegisterBank", "&", "RB", "=", "*", "RBI", ".", "getRegBank", "(", "LHS", ",", "MRI", ",", "TRI", ")", ";", "if", "(", "RB", ".", "getID", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "const", "auto", "Pred", "=", "(", "CmpInst", "::", "Predicate", ")", "CCMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getPredicate", "(", ")", ";", "if", "(", "Pred", "!=", "CmpInst", "::", "ICMP_NE", "&&", "Pred", "!=", "CmpInst", "::", "ICMP_EQ", ")", "return", "false", ";", "const", "unsigned", "CmpWidth", "=", "MRI", ".", "getType", "(", "LHS", ")", ".", "getSizeInBits", "(", ")", ";", "unsigned", "CBOpc", "=" ]

[ "NumLanes", ";", "++", "i", ")", "{" ]

[ "size_t", "NumLanes", "=", "Op", ".", "getSimpleValueType", "(", ")", ".", "getVectorNumElements", "(", ")", ";", "SDValue", "Mask", "=", "DAG", ".", "getConstant", "(", "LaneT", ".", "getSizeInBits", "(", ")", "-", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "unsigned", "ShiftOpcode", "=", "Op", ".", "getOpcode", "(", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "ShiftedElements", ";", "DAG", ".", "ExtractVectorElements", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "ShiftedElements", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "ShiftElements", ";", "DAG", ".", "ExtractVectorElements", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "ShiftElements", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "UnrolledOps", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<" ]

[ "override", "{" ]

[ "const", "LM32Subtarget", "*", "getSubtargetImpl", "(", ")", "const" ]

[ "output_addr_const", "(", "file", ",", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";" ]

[ "break", ";", "case", "'", "F", "'", ":", "gcc_assert", "(", "CONST_INT_P", "(", "op", ")", ")", ";", "switch", "(", "INTVAL", "(", "op", ")", ")", "{", "case", "<NUM_LIT>", ":", "case", "'", "c", "'", ":", "case", "'", "C", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "C", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "'", "z", "'", ":", "case", "'", "Z", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "Z", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "'", "s", "'", ":", "case", "'", "S", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "S", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "'", "o", "'", ":", "case", "'", "O", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "O", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "'", "i", "'", ":", "case", "'", "I", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "I", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "case", "'", "u", "'", ":", "case", "'", "U", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "U", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "'", "G", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "rx_gp_base_regnum", "(", ")", "]", ")", ";", "break", ";", "case", "'", "H", "'", ":", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "op", ")", "+", "(", "WORDS_BIG_ENDIAN", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "]", ")", ";", "break", ";", "case", "CONST_INT", ":", "{", "HOST_WIDE_INT", "v", "=", "INTVAL", "(", "op", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "v", "=", "v", ">>", "<NUM_LIT>", ";", "v", "=", "v", ">>", "<NUM_LIT>", ";", "rx_print_integer", "(", "file", ",", "v", ")", ";", "break", ";", "}", "case", "CONST_DOUBLE", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "rx_print_integer", "(", "file", ",", "CONST_DOUBLE_HIGH", "(", "op", ")", ")", ";", "break", ";", "case", "MEM", ":", "if", "(", "!", "WORDS_BIG_ENDIAN", ")", "op", "=", "adjust_address", "(", "op", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "output_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "'", "L", "'", ":", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "op", ")", "+", "(", "WORDS_BIG_ENDIAN", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", "]", ")", ";", "break", ";", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "rx_print_integer", "(", "file", ",", "INTVAL", "(", "op", ")", "&", "<NUM_LIT>", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "rx_print_integer", "(", "file", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "break", ";", "case", "MEM", ":", "if", "(", "WORDS_BIG_ENDIAN", ")", "op", "=", "adjust_address", "(", "op", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "output_address", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "'", "N", "'", ":", "gcc_assert", "(", "CONST_INT_P", "(", "op", ")", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "rx_print_integer", "(", "file", ",", "-", "INTVAL", "(", "op", ")", ")", ";", "break", ";", "case", "'", "P", "'", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "rx_pid_base_regnum", "(", ")", "]", ")", ";", "break", ";", "case", "'", "R", "'", ":", "gcc_assert", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", "<=", "<NUM_LIT>", ")", ";", "unsigned_load", "=", "true", ";", "case", "'", "Q", "'", ":", "if", "(", "MEM_P", "(", "op", ")", ")", "{", "HOST_WIDE_INT", "offset", ";", "rtx", "mem", "=", "op", ";", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "REG_P", "(", "op", ")", ")", "offset", "=", "<NUM_LIT>", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", "{", "rtx", "displacement", ";", "if", "(", "REG_P", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", "{", "displacement", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "displacement", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "REG_P", "(", "op", ")", ")", ";", "}", "gcc_assert", "(", "CONST_INT_P", "(", "displacement", ")", ")", ";", "offset", "=", "INTVAL", "(", "displacement", ")", ";", "gcc_assert", "(", "offset", ">=", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "%ld", "<STR_LIT>", ",", "offset", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "[", "<STR_LIT>", ")", ";", "rx_print_operand", "(", "file", ",", "op", ",", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "].", "<STR_LIT>", ")", ";", "switch", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem", ")", ")", ")", "{", "case", "<NUM_LIT>", ":", "gcc_assert", "(", "offset", "<=", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "unsigned_load", "?", "<STR_LIT>", "UB", "<STR_LIT>", ":", "<STR_LIT>", "B", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "gcc_assert", "(", "offset", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "offset", "<=", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "unsigned_load", "?", "<STR_LIT>", "UW", "<STR_LIT>", ":", "<STR_LIT>", "W", "<STR_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "gcc_assert", "(", "offset", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "offset", "<=", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "L", "<STR_LIT>", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "}", "default", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", ")", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "CONST_INT", ")", "{", "if", "(", "print_hash", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "#", "<STR_LIT>", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", "(", "<STR_LIT>", ")", ";", "rx_print_operand", "(", "file", ",", "XEXP", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ",", "'", "A", "'", ")", ";", "fprintf", "(", "file", ",", "<STR_LIT>", " + ", "<STR_LIT>", ")", ";" ]

[ ".", "FullyAllocated", ";" ]

[ "MachineFrameInfo", "&", "FrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "assert", "(", "ST", ".", "hasMAIInsts", "(", ")", "&&", "FrameInfo", ".", "isSpillSlotObjectIndex", "(", "FI", ")", ")", ";", "auto", "&", "Spill", "=", "VGPRToAGPRSpills", "[", "FI", "]", ";", "if", "(", "!", "Spill", ".", "Lanes", ".", "empty", "(", ")", ")", "return", "Spill", ".", "FullyAllocated", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FI", ")", ";", "unsigned", "NumLanes", "=", "Size", "/", "<NUM_LIT>", ";", "Spill", ".", "Lanes", ".", "resize", "(", "NumLanes", ",", "AMDGPU", "::", "NoRegister", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "isAGPRtoVGPR", "?", "AMDGPU", "::", "VGPR_32RegClass", ":", "AMDGPU", "::", "AGPR_32RegClass", ";", "auto", "Regs", "=", "RC", ".", "getRegisters", "(", ")", ";", "auto", "&", "SpillRegs", "=", "isAGPRtoVGPR", "?", "SpillAGPR", ":", "SpillVGPR", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "Spill", ".", "FullyAllocated", "=", "true", ";", "BitVector", "OtherUsedRegs", ";", "OtherUsedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "const", "uint32_t", "*", "CSRMask", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ")", ";", "if", "(", "CSRMask", ")", "OtherUsedRegs", ".", "setBitsInMask", "(", "CSRMask", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "SpillAGPR", ")", "OtherUsedRegs", ".", "set", "(", "Reg", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "SpillVGPR", ")", "OtherUsedRegs", ".", "set", "(", "Reg", ")", ";", "SmallVectorImpl", "<", "MCPhysReg", ">", "::", "const_iterator", "NextSpillReg", "=", "Regs", ".", "begin", "(", ")", ";", "for", "(", "int", "I", "=", "NumLanes", "-", "<NUM_LIT>", ";", "I", ">=", "<NUM_LIT>", ";", "--", "I", ")", "{", "NextSpillReg", "=", "std", "::", "find_if", "(", "NextSpillReg", ",", "Regs", ".", "end", "(", ")", ",", "[", "&", "MRI", ",", "&", "OtherUsedRegs", "]", "(", "MCPhysReg", "Reg", ")", "{", "return", "MRI", ".", "isAllocatable", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", "&&", "!", "OtherUsedRegs", "[", "Reg", "]", ";", "}", ")", ";", "if", "(", "NextSpillReg", "==", "Regs", ".", "end", "(", ")", ")", "{", "Spill", ".", "FullyAllocated", "=", "false", ";", "break", ";", "}", "OtherUsedRegs", ".", "set", "(", "*", "NextSpillReg", ")", ";", "SpillRegs", ".", "push_back", "(", "*", "NextSpillReg", ")", ";", "Spill", ".", "Lanes", "[", "I", "]", "=", "*", "NextSpillReg", "++", ";", "}", "return", "Spill" ]

[ "}" ]

[ "static", "SDValue", "lowerShuffleWithUNPCK", "(", "const", "SDLoc", "&", "DL", ",", "MVT", "VT", ",", "ArrayRef", "<", "int", ">", "Mask", ",", "SDValue", "V1", ",", "SDValue", "V2", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Unpckl", ";", "createUnpackShuffleMask", "(", "VT", ",", "Unpckl", ",", "true", ",", "false", ")", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "Unpckl", ",", "V1", ",", "V2", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V1", ",", "V2", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "Unpckh", ";", "createUnpackShuffleMask", "(", "VT", ",", "Unpckh", ",", "false", ",", "false", ")", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "Unpckh", ",", "V1", ",", "V2", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V1", ",", "V2", ")", ";", "ShuffleVectorSDNode", "::", "commuteMask", "(", "Unpckl", ")", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "Unpckl", ",", "V1", ",", "V2", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V2", ",", "V1", ")", ";", "ShuffleVectorSDNode", "::", "commuteMask", "(", "Unpckh", ")", ";", "if", "(", "isShuffleEquivalent", "(", "Mask", ",", "Unpckh", ",", "V1", ",", "V2", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V2", ",", "V1", ")", ";", "return", "SDValue", "(", ")", ";" ]

[ ";" ]

[ "if", "(", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips", ")", "||", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips64", ")", ")", "IsLittleEndian", "=", "false", ";", "if", "(", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips64el", ")", "||", "(", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "mips64", ")", ")", "{", "PointerSize", "=", "CalleeSaveStackSlotSize", "=", "<NUM_LIT>", ";", "}", "AlignmentIsInBytes", "=", "false", ";", "Data16bitsDirective", "=", "<STR_LIT>", "\\t.2byte\\t", "<STR_LIT>", ";", "Data32bitsDirective", "=", "<STR_LIT>", "\\t.4byte\\t", "<STR_LIT>", ";", "Data64bitsDirective", "=", "<STR_LIT>", "\\t.8byte\\t", "<STR_LIT>", ";", "PrivateGlobalPrefix", "=", "<STR_LIT>", "$", "<STR_LIT>", ";", "CommentString", "=", "<STR_LIT>", "#", "<STR_LIT>", ";", "ZeroDirective", "=", "<STR_LIT>", "\\t.space\\t", "<STR_LIT>", ";", "GPRel32Directive", "=", "<STR_LIT>", "\\t.gpword\\t", "<STR_LIT>", ";", "GPRel64Directive", "=", "<STR_LIT>", "\\t.gpdword\\t", "<STR_LIT>" ]

[ "static", "bool", "mips_hard_regno_call_part_clobbered", "(", "unsigned", "int", ",", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_FLOATXX", "&&", "hard_regno_nregs", "(", "regno", ",", "mode", ")", "==", "<NUM_LIT>", "&&", "FP_REG_P", "(", "regno", ")", "&&", "(", "regno", "&", "<NUM_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "true", ";", "if", "(", "ISA_HAS_MSA", "&&", "FP_REG_P", "(", "regno", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "<NUM_LIT>", ")", "return", "true", ";", "return", "false", ";", "}" ]

[ "Implement", "TARGET_HARD_REGNO_CALL_PART_CLOBBERED", ".", "Odd-numbered", "single-precision", "registers", "are", "not", "considered", "callee-saved", "for", "o32", "FPXX", "as", "they", "will", "be", "clobbered", "when", "run", "on", "an", "FR=1", "FPU", ".", "MSA", "vector", "registers", "with", "MODE", ">", "64", "bits", "are", "part", "clobbered", "too", "." ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "xor", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

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

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

[ "void", "GBZ80PassConfig", "::", "addPreEmitPass" ]

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

[ "def", "A64FXGI124", ":", "ProcResGroup", "<", "[", "A64FXIPEXA", ",", "A64FXIPEXB" ]

[ "}" ]

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

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

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

[ "<FIXS>", "fatal_error", "(", "input_location", ",", "<STR_LIT>", "conflicting use of -mcustom switches, target attributes, ", "<STR_LIT>", "<FIXE>" ]

[ "<STR_LIT>", "-fno-math-errno is specified", "<STR_LIT>", ",", "N2FPU_NAME", "(", "i", ")", ")", ";", "if", "(", "errors", "||", "custom_code_conflict", ")", "<BUGS>", "fatal_error", "(", "<STR_LIT>", "conflicting use of -mcustom switches, target attributes, ", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "and/or __builtin_custom_ functions", "<STR_LIT>", ")", ";", "}" ]

[ "DL", ",", "VT", ",", "Op1", ",", "SExt", ")", ";" ]

[ "if", "(", "SDValue", "V", "=", "combineAddOrSubToHADDorHSUB", "(", "N", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ZERO_EXTEND", "&&", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "TLI", ".", "isTypeLegal", "(", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ")", ")", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "SExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VT", ",", "Op0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", "," ]

[ "<FIXS>", "OptionalImmIndexMap", "OptionalIdx", ";", "<FIXE>" ]

[ "void", "AMDGPUAsmParser", "::", "cvtFlat", "(", "MCInst", "&", "Inst", ",", "const", "OperandVector", "&", "Operands", ")", "{", "<BUGS>", "std", "::", "map", "AMDGPUOperand", "::", "ImmTy", ",", "unsigned", ">", "OptionalIdx", ";", "<BUGE>", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "Operands", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "AMDGPUOperand", "&", "Op", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "i", "]", ")", ";" ]

[ "}", "else", "{" ]

[ "res", "=", "parseOModOperand", "(", "Operands", ")", ";", "}", "else", "if", "(", "Op", ".", "Type", "==", "AMDGPUOperand", "::", "ImmTySdwaDstSel", "||", "Op", ".", "Type", "==", "AMDGPUOperand", "::", "ImmTySdwaSrc0Sel", "||", "Op", ".", "Type", "==", "AMDGPUOperand", "::", "ImmTySdwaSrc1Sel", ")", "{", "res", "=", "parseSDWASel", "(", "Operands", ",", "Op", ".", "Name", ",", "Op", ".", "Type", ")", ";", "}", "else", "if", "(", "Op", ".", "Type", "==", "AMDGPUOperand", "::", "ImmTySdwaDstUnused", ")", "{", "res", "=", "parseSDWADstUnused", "(", "Operands", ")", ";" ]

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

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", ",", "MCOperand", "::", "createReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "const", "MCOperand", "&", "Imm4Op", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "Imm4Op", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Unexpected operand type!", "<STR_LIT>", ")", ";", "MI", ".", "addOperand", "(", "Imm4Op", ")", ";", "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>", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", ",", "MCOperand", "::", "createReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "MCOperand", "::", "createReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "MI", ".", "insert", "(", "MI", ".", "begin", "(", ")", "+", "<NUM_LIT>", ",", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "<NUM_LIT>", ")", ")", ";", "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>" ]

[ "<FIXS>", "if", "(", "TII", "->", "mayWriteLDSThroughDMA", "(", "MI", ")", ")", "<FIXE>" ]

[ "if", "(", "AS", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "AS", "!=", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "continue", ";", "<BUGS>", "if", "(", "mayWriteLDSThroughDMA", "(", "MI", ")", ")", "<BUGE>", "continue", ";", "unsigned", "RegNo", "=", "SQ_MAX_PGM_VGPRS", "+", "EXTRA_VGPR_LDS", ";" ]

[ "<FIXS>", "SDValue", "Zero", "=", "CurDAG", "->", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ")", ";", "<FIXE>" ]

[ "}", "<BUGS>", "SDValue", "Zero", "=", "CurDAG", "->", "getConstant", "(", "<NUM_LIT>", ",", "N", ".", "getValueType", "(", ")", ")", ";", "<BUGE>", "SDValue", "Neg", "=", "CurDAG", "->", "getNode", "(", "ISD", "::", "SUB", ",", "dl", ",", "N", ".", "getValueType", "(", ")", ",", "Zero", ",", "RHS", ")", ";", "AM", ".", "IndexReg", "=", "Neg", ";", "AM", ".", "Scale", "=", "<NUM_LIT>", ";" ]

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

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "unspec", ":", "DI", "[", "(", "match_dup", "<NUM_LIT>", ")", "]", "UNSPEC_CVTLQ", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "float", ":", "SF", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "adjust_address", "(", "operands", "[", "<NUM_LIT>", "]", ",", "SFmode", ",", "<NUM_LIT>", ")", "operands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_REG", "(", "DImode" ]

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

[ "if", "(", "pFormat", ".", "hasGOTPLT", "(", ")", ")", "applyOne", "(", "llvm", "::", "ELF", "::", "DT_PLTGOT", ",", "pFormat", ".", "getGOTPLT", "(", ")", "." ]

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

[ "bool", "isFLATGlobal", "(", "uint16_t", "Opcode" ]

[ "const", "TargetLowering", "&", "TLI", "=", "CurDAG", "->", "getTargetLoweringInfo", "(", ")", ";" ]

[ "TargetLowering", "::", "ArgListTy", "Args", ";", "auto", "&", "DL", "=", "CurDAG", "->", "getDataLayout", "(", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "*", "CurDAG", ")", ";", "CLI", ".", "setChain", "(", "CurDAG", "->", "getRoot", "(", ")", ")", ".", "setCallee", "(", "CallingConv", "::", "C", ",", "Type", "::", "getVoidTy", "(", "*", "CurDAG", "->", "getContext", "(", ")", ")", ",", "CurDAG", "->", "getExternalSymbol", "(", "<STR_LIT>", "__main", "<STR_LIT>", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "<NUM_LIT>", ")", ";" ]

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

[ "def", "VGEG", ":", "TernaryVRV", "<", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "," ]

[ "<NUM_LIT>", ";" ]

[ "*", "Dst", "=", "(", "Value", "-", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_rodata", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_end_of_text", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", "+" ]

[ ",", "asm", ",", "node", ">", "{" ]

[ "def", "X", ":", "BaseTestBranch", "<", "GPR64", ",", "tbz_imm32_63", ",", "op" ]

[ "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "********** Register Numbering **********\\n", "<STR_LIT>", "<STR_LIT>", "********** Function: ", "<STR_LIT>", "<<", "MF", ".", "getName", "(", ")", "<<", "'", "\\n", "'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "FrameInfo", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Arg VReg ", "<STR_LIT>", "<<", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "<<", "<STR_LIT>", " -> WAReg ", "<STR_LIT>", "<<", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "<NUM_LIT>", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "<NUM_LIT>", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "VReg ", "<STR_LIT>", "<<", "VReg", "<<", "<STR_LIT>", " -> WAReg ", "<STR_LIT>", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "VReg ", "<STR_LIT>", "<<", "VReg", "<<", "<STR_LIT>", " -> WAReg ", "<STR_LIT>", "<<", "CurReg", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "if", "(", "FrameInfo", ".", "getStackSize", "(", ")", ">", "<NUM_LIT>", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "PReg SP ", "<STR_LIT>", "<<", "CurReg", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "MFI", ".", "addPReg", "(", "WebAssembly", "::", "SP32", ",", "CurReg", "++", ")", ";", "}", "return", "true", ";", "}" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "emit_insn", "(", "gen_floatdi", "FP_ISA3", ":", "mode", ">", "<NUM_LIT>", "(", "result", ",", "di", ")", ")", "DONE", "<BUGS>", "}", ")", "<BUGE>", "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")" ]

[ "SDValue", "Elt", "=", "DAG", ".", "getShuffleScalarElt", "(", "Op", ".", "getNode", "(", ")", ",", "Index", ")", ";" ]

[ "SDValue", "Idx", "=", "Mask", ".", "getOperand", "(", "Index", ")", ";", "if", "(", "Idx", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "{", "++", "NumZeros", ";", "continue", ";", "}" ]

[ "!=", "SYMBOL_REF", ")", "return", "TLS_MODEL_NONE", ";" ]

[ "enum", "tls_model", "tls_symbolic_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")" ]

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

[ "addPass", "(", "createAtomicExpandPass", "(", "&", "getSparcTargetMachine", "(" ]

[ "MemAddr", ")", ";" ]

[ "assert", "(", "NumVecs", ">=", "<NUM_LIT>", "&&", "NumVecs", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "VLDSTLane NumVecs out-of-range", "<STR_LIT>", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "MemAddr", ",", "Align", ";", "if", "(", "!", "SelectAddrMode6", "(", "N", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MemAddr", ",", "Align", ")", ")", "return", "NULL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "Lane", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "NumVecs", "+", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "EVT", "VT", "=", "IsLoad", "?", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ":", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "bool", "is64BitVector", "=", "VT", ".", "is64BitVector", "(", ")", ";", "unsigned", "NumElts", "=", "<NUM_LIT>", ";", "int", "SubregIdx", "=", "<NUM_LIT>", ";", "EVT", "RegVT", "=", "VT", ";", "if", "(", "!", "is64BitVector", ")", "{", "RegVT", "=", "GetNEONSubregVT", "(", "VT", ")", ";", "NumElts", "=", "RegVT", ".", "getVectorNumElements", "(", ")", ";", "SubregIdx", "=", "(", "Lane", "<", "NumElts", ")", "?", "ARM", "::", "DSUBREG_0", ":", "ARM", "::", "DSUBREG_1", ";", "}", "unsigned", "OpcodeIndex", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unhandled vld/vst lane type", "<STR_LIT>", ")", ";", "case", "MVT", "::", "v8i8", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4i16", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v2f32", ":", "case", "MVT", "::", "v2i32", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v8i16", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v4i32", ":", "OpcodeIndex", "=", "<NUM_LIT>", ";", "break", ";", "}", "SDValue", "Pred", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "Ops", ".", "push_back", "(" ]

[ "Invalid fixup offset!", "<STR_LIT>", ")", ";" ]

[ "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "<STR_LIT>" ]

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

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

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

[ "(", "define_mode_iterator", "SWI48", "[", "SI", "(", "DI" ]

[ "}" ]

[ "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";" ]

[ "static", "reg_class_t", "sh_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", "==", "GBR_REG", ")", "return", "rclass", "==", "R0_REGS", "?", "NO_REGS", ":", "R0_REGS", ";", "if", "(", "MEM_P", "(", "x", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "GBR_REG", ")", "return", "rclass", "==", "R0_REGS", "?", "NO_REGS", ":", "R0_REGS", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "==", "GBR_REG", ")", "return", "NO_REGS", ";", "if", "(", "in_p", ")", "{", "if", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "immediate_operand", "(", "(", "x", ")", ",", "mode", ")", "&&", "!", "(", "(", "fp_zero_operand", "(", "x", ")", "||", "fp_one_operand", "(", "x", ")", ")", "&&", "mode", "==", "SFmode", ")", ")", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insf__frn", ";", "return", "NO_REGS", ";", "case", "E_DFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_indf__frn", ";", "return", "NO_REGS", ";", "case", "E_SImode", ":", "return", "FPUL_REGS", ";", "default", ":", "abort", "(", ")", ";", "}", "if", "(", "rclass", "==", "FPUL_REGS", "&&", "(", "(", "REG_P", "(", "x", ")", "&&", "(", "REGNO", "(", "x", ")", "==", "MACL_REG", "||", "REGNO", "(", "x", ")", "==", "MACH_REG", "||", "REGNO", "(", "x", ")", "==", "T_REG", ")", ")", "||", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "rclass", "==", "FPUL_REGS", "&&", "immediate_operand", "(", "x", ",", "mode", ")", ")", "{", "if", "(", "satisfies_constraint_I08", "(", "x", ")", "||", "fp_zero_operand", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "mode", "==", "SFmode", ")", "return", "FP_REGS", ";", "sri", "->", "icode", "=", "CODE_FOR_reload_insi__i_fpul", ";", "return", "NO_REGS", ";", "}", "if", "(", "rclass", "==", "FPSCR_REGS", "&&", "(", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "||", "(", "MEM_P", "(", "x", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "PLUS", ")", ")", ")", "return", "GENERAL_REGS", ";", "}", "if", "(", "(", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "(", "REG_P", "(", "x", ")", "&&", "(", "GENERAL_OR_AP_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", "||", "(", "FP_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", "&&", "mode", "==", "SImode", "&&", "TARGET_FMOVD", ")", ")", ")", ")", "||", "(", "REGCLASS_HAS_GENERAL_REG", "(", "rclass", ")", "&&", "REG_P", "(", "x", ")", "&&", "FP_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", ")", ")", "return", "FPUL_REGS", ";", "if", "(", "(", "rclass", "==", "FPUL_REGS", "||", "(", "REGCLASS_HAS_FP_REG", "(", "rclass", ")", "&&", "mode", "==", "SImode", ")", ")", "&&", "(", "MEM_P", "(", "x", ")", "||", "(", "REG_P", "(", "x", ")", "&&", "(", "REGNO", "(", "x", ")", ">=", "FIRST_PSEUDO_REGISTER", "||", "REGNO", "(", "x", ")", "==", "T_REG", "||", "system_reg_operand", "(", "x", ",", "VOIDmode", ")", ")", ")", ")", ")", "{", "if", "(", "rclass", "==", "FPUL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "if", "(", "(", "rclass", "==", "MAC_REGS", "||", "rclass", "==", "PR_REGS", ")", "&&", "REG_P", "(", "x", ")", "&&", "!", "GENERAL_REGISTER_P", "(", "REGNO", "(", "x", ")", ")", "&&", "rclass", "!=", "REGNO_REG_CLASS", "(", "REGNO", "(", "x", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "rclass", "==", "FPUL_REGS", "&&", "true_regnum", "(", "x", ")", "==", "-", "<NUM_LIT>", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "rclass", "!=", "R0_REGS", "&&", "satisfies_constraint_Sdd", "(", "x", ")", "&&", "sh_disp_addr_displacement", "(", "x", ")", "<=", "sh_max_mov_insn_displacement", "(", "mode", ",", "false", ")", ")", "return", "R0_REGS", ";", "if", "(", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "rclass", "!=", "R0_REGS", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "true_regnum", "(", "x", ")", "==", "-", "<NUM_LIT>", ")", "return", "R0_REGS", ";", "return", "NO_REGS", ";", "}" ]

[ "Implement", "TARGET_SECONDARY_RELOAD", "." ]

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

[ "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "=", "sw", ";", "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

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

[ "def", "_D", ":", "sve_int_bin_pred_shift_imm", "<", "{", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", "}", ",", "opc", ",", "asm", ",", "ZPR64", ",", "vecshiftR64", ",", "ElementSizeD", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

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

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

[ "ResultReg", ")", ";" ]

[ "MovCCOpc", "=", "isThumb2", "?", "ARM", "::", "t2MOVCCr", ":", "ARM", "::", "MOVCCr", ";", "}", "else", "{", "RC", "=", "isThumb2", "?", "&", "ARM", "::", "rGPRRegClass", ":", "&", "ARM", "::", "GPRRegClass", ";", "if", "(", "!", "isNegativeImm", ")", "MovCCOpc", "=", "isThumb2", "?", "ARM", "::", "t2MOVCCi", ":", "ARM", "::", "MOVCCi", ";", "else", "MovCCOpc", "=", "isThumb2", "?", "ARM", "::", "t2MVNCCi", ":", "ARM", "::", "MVNCCi", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "if", "(", "!", "UseImm", ")", "{", "Op2Reg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "MovCCOpc", ")", ",", "Op2Reg", ",", "<NUM_LIT>", ")", ";", "Op1Reg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "MovCCOpc", ")", ",", "Op1Reg", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "MovCCOpc", ")", ",", "ResultReg", ")", ".", "addReg", "(", "Op2Reg", ")", ".", "addReg", "(", "Op1Reg", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ")", ";", "}", "else", "{", "Op1Reg", "=", "constrainOperandRegClass", "(", "TII", ".", "get", "(", "MovCCOpc", ")", ",", "Op1Reg", ",", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "MovCCOpc", ")", ",", "ResultReg", ")", ".", "addReg", "(", "Op1Reg", ")", ".", "addImm", "(", "Imm", ")", ".", "addImm", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "ARM", "::", "CPSR", ")", ";", "}", "updateValueMap", "(", "I", "," ]

[ "#", "<STR_LIT>", ")", "FPR32", ":", "$", "Rn", ",", "FPR32", ":", "$", "Rm", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "i32", "(", "OpNode", "(", "i32", "FPR32", ":", "$", "Rn", ")", ",", "(", "i32", "FPR32", ":", "$", "Rm", ")", ")", ")", ",", "(", "!", "cast", "<", "Instruction", ">", "(", "NAME" ]

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

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "operand_subword", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "DImode", ")" ]

[ "}", ")" ]

[ "(", "match_operand", ":", "V2SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "sh_expand_binop_v2sf", "(", "MULT", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "DONE" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "def", "vecshiftL64", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";" ]