From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 99359 invoked by alias); 12 Jan 2016 07:21:02 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 99338 invoked by uid 89); 12 Jan 2016 07:21:01 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=0.2 required=5.0 tests=AWL,BAYES_50,FREEMAIL_FROM,KAM_ASCII_DIVIDERS,RCVD_IN_DNSWL_LOW,SPF_PASS autolearn=no version=3.3.2 spammy=35810, sk:machine, Structure, naked X-HELO: mail-oi0-f51.google.com Received: from mail-oi0-f51.google.com (HELO mail-oi0-f51.google.com) (209.85.218.51) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-GCM-SHA256 encrypted) ESMTPS; Tue, 12 Jan 2016 07:20:58 +0000 Received: by mail-oi0-f51.google.com with SMTP id o124so58419829oia.3 for ; Mon, 11 Jan 2016 23:20:58 -0800 (PST) MIME-Version: 1.0 X-Received: by 10.202.210.151 with SMTP id j145mr91426843oig.114.1452583256708; Mon, 11 Jan 2016 23:20:56 -0800 (PST) Received: by 10.202.97.133 with HTTP; Mon, 11 Jan 2016 23:20:56 -0800 (PST) Date: Tue, 12 Jan 2016 07:21:00 -0000 Message-ID: Subject: Re: [PATCH : RL78] Disable interrupts during hardware multiplication routines From: Kaushik M Phatak To: Nick Clifton Cc: dj@redhat.com, Mike Stump , gcc-patches@gcc.gnu.org, "kaushik.phatak@kpit.com" Content-Type: multipart/mixed; boundary=001a113ded4205f3af05291de597 X-SW-Source: 2016-01/txt/msg00669.txt.bz2 --001a113ded4205f3af05291de597 Content-Type: text/plain; charset=UTF-8 Content-length: 11064 Hi Nick, Thanks for your detailed review. Please find an updated version of this patch here. I have tried to modify it as per your suggestions. > I would suggest: > static bool Done. > + if (recog_memoized (insn) == CODE_FOR_udivmodsi4_g13 > have an attribute on these insns, and then test for that here. Done. Added attribute 'is_g13_muldiv_insn' which gets tested in this function. > + return 1; > If you change the function to "bool" then return "true" here. > + return 0; Done. > if (rl78_is_naked_func ()) > return; > - > + > Why are you adding a extraneous space here ? Done. This was a typo while extracting the patch. > + if (MUST_SAVE_MDUC_REGISTER && (!crtl->is_leaf || check_mduc_usage ())) > It would be nice to update the stack size computation performed I have tried to add code to update 'fs' while checking for 'framesize_locals'. Please let me know if this is OK. > + emit_insn (gen_push (gen_rtx_REG (HImode, AX_REG))); > it would be cleaner to use a for loop and a small structure containing > the address, mode and volatility to be saved. I have created simple structure for this, though the volatility is always set and may not need to be a separate member. Please let me know if this is OK. > Hence I would suggest: > fprintf (file, "\t; preserves MDUC registers\n"); Done. > +This is the default. > It is *not* the default! Updated this. However, the registers are saved when -mmul=g13 and -mg13 is passed. > +@item -msave-mduc-in-interrupts > +@item -mno-save-mduc-in-interrupts > +@opindex msave-mduc-in-interrupts > You should also mention that even if this option is enabled Added information regarding registers being saved based on certain conditions being met. Kindly review the updated patch and let me know if it is OK. This is regression tested for rl78 -msim and -mg13 + -msave-mduc-in-interrupts Best Regards, Kaushik gcc/ChangeLog 2016-01-12 Kaushik Phatak * config/rl78/rl78.c (rl78_expand_prologue): Save the MDUC related registers in all interrupt handlers if necessary. (rl78_option_override): Add warning. (MUST_SAVE_MDUC_REGISTER): New macro. (rl78_expand_epilogue): Restore the MDUC registers if necessary. * config/rl78/rl78.c (check_mduc_usage): New function. * config/rl78/rl78.c (mduc_regs): New structure to hold MDUC register data. * config/rl78/rl78.md (is_g13_muldiv_insn): New attribute. * config/rl78/rl78.md (mulsi3_g13): Add is_g13_muldiv_insn attribute. * config/rl78/rl78.md (udivmodsi4_g13): Add is_g13_muldiv_insn attribute. * config/rl78/rl78.md (mulhi3_g13): Add is_g13_muldiv_insn attribute. * config/rl78/rl78.opt (msave-mduc-in-interrupts): New option. (mno-save-mduc-in-interrupts): New option. * doc/invoke.texi (@item -msave-mduc-in-interrupts): New item. (@item -mno-save-mduc-in-interrupts): New item Index: gcc/config/rl78/rl78.c =================================================================== --- gcc/config/rl78/rl78.c(revision 2871) +++ gcc/config/rl78/rl78.c(working copy) @@ -83,6 +83,22 @@ "sp", "ap", "psw", "es", "cs" }; +/* Structure for G13 MDUC registers. */ +struct mduc_reg_type +{ + unsigned int address; + enum machine_mode mode; + bool is_volatile; +}; + +struct mduc_reg_type mduc_regs[NUM_OF_MDUC_REGS] = + {{0xf00e8, QImode, true}, + {0xffff0, HImode, true}, + {0xffff2, HImode, true}, + {0xf2224, HImode, true}, + {0xf00e0, HImode, true}, + {0xf00e2, HImode, true}}; + struct GTY(()) machine_function { /* If set, the rest of the fields have been computed. */ @@ -342,6 +358,10 @@ #undef TARGET_OPTION_OVERRIDE #define TARGET_OPTION_OVERRIDErl78_option_override +#define MUST_SAVE_MDUC_REGISTERS \ + (!TARGET_NO_SAVE_MDUC_REGISTERS \ + && (is_interrupt_func (NULL_TREE)) && RL78_MUL_G13) + static void rl78_option_override (void) { @@ -366,6 +386,9 @@ /* Address spaces are currently only supported by C. */ error ("-mes0 can only be used with C"); + if (TARGET_SAVE_MDUC_REGISTERS && !(TARGET_G13 || RL78_MUL_G13)) + warning (0, "mduc registers only saved for G13 target"); + switch (rl78_cpu_type) { case CPU_UNINIT: @@ -1307,6 +1330,23 @@ return (lookup_attribute ("naked", DECL_ATTRIBUTES (current_function_decl)) != NULL_TREE); } +/* Check if the block uses mul/div insns for G13 target. */ +static bool +check_mduc_usage () +{ + rtx insn; + basic_block bb; + FOR_EACH_BB_FN (bb, cfun) + { + FOR_BB_INSNS (bb, insn) + { + if (get_attr_is_g13_muldiv_insn (insn) == IS_G13_MULDIV_INSN_YES) + return true; + } + } + return false; +} + /* Expand the function prologue (from the prologue pattern). */ void rl78_expand_prologue (void) @@ -1371,6 +1411,28 @@ F (emit_insn (gen_push (ax))); } + /* Save MDUC registers inside interrupt routine. */ + if (MUST_SAVE_MDUC_REGISTERS && (!crtl->is_leaf || check_mduc_usage ())) + { + rtx mem_mduc; + + for (int i = 0; i machine->framesize_locals + cfun->machine->framesize_outgoing; + if (MUST_SAVE_MDUC_REGISTERS && (!crtl->is_leaf || check_mduc_usage ())) + fs = fs + NUM_OF_MDUC_REGS * 2; if (fs > 0) { /* If we need to subtract more than 254*3 then it is faster and @@ -1426,6 +1490,8 @@ else { fs = cfun->machine->framesize_locals + cfun->machine->framesize_outgoing; + if (MUST_SAVE_MDUC_REGISTERS && (!crtl->is_leaf || check_mduc_usage ())) +fs = fs + NUM_OF_MDUC_REGS * 2; if (fs > 254 * 3) { emit_move_insn (ax, sp); @@ -1444,6 +1510,29 @@ } } + /* Restore MDUC registers from interrupt routine. */ + if (MUST_SAVE_MDUC_REGISTERS && (!crtl->is_leaf || check_mduc_usage ())) + { + rtx mem_mduc; + + for (int i = NUM_OF_MDUC_REGS-1; i >= 0; i--) + { +emit_insn (gen_pop (gen_rtx_REG (HImode, AX_REG))); + if (mduc_regs[i].mode == QImode) + { + mem_mduc = gen_rtx_MEM (QImode, GEN_INT (mduc_regs[i].address)); + MEM_VOLATILE_P (mem_mduc) = 1; + emit_insn (gen_movqi (mem_mduc, gen_rtx_REG (QImode, A_REG))); + } + else + { + mem_mduc = gen_rtx_MEM (HImode, GEN_INT (mduc_regs[i].address)); + MEM_VOLATILE_P (mem_mduc) = 1; + emit_insn (gen_movhi (mem_mduc, gen_rtx_REG (HImode, AX_REG))); + } + } + } + /* Save ES register inside interrupt functions. */ if (is_interrupt_func (cfun->decl) && cfun->machine->uses_es) { @@ -1599,6 +1688,9 @@ if (cfun->machine->uses_es) fprintf (file, "\t; uses ES register\n"); + + if (MUST_SAVE_MDUC_REGISTERS) + fprintf (file, "\t; preserves MDUC registers\n"); } /* Return an RTL describing where a function return value of type RET_TYPE Index: gcc/config/rl78/rl78.h =================================================================== --- gcc/config/rl78/rl78.h(revision 2871) +++ gcc/config/rl78/rl78.h(working copy) @@ -28,6 +28,7 @@ #define TARGET_G14(rl78_cpu_type == CPU_G14) +#define NUM_OF_MDUC_REGS 6 #define TARGET_CPU_CPP_BUILTINS() \ do \ Index: gcc/config/rl78/rl78.md =================================================================== --- gcc/config/rl78/rl78.md(revision 2871) +++ gcc/config/rl78/rl78.md(working copy) @@ -78,6 +78,7 @@ (include "rl78-virt.md") (include "rl78-real.md") +(define_attr "is_g13_muldiv_insn" "yes,no" (const_string "no")) ;; Function Prologue/Epilogue Instructions @@ -416,7 +417,8 @@ movw ax, 0xffff6 ; MDBL movw %h0, ax ; end of mulhi macro" - [(set_attr "valloc" "macax")] + [(set_attr "valloc" "macax") + (set_attr "is_g13_muldiv_insn" "yes")] ) ;; 0xFFFF0 is MACR(L). 0xFFFF2 is MACR(H) but we don't care about it @@ -496,7 +498,8 @@ movwax, !0xf00e0; MDCL movw%H0, ax ; end of mulsi macro" - [(set_attr "valloc" "macax")] + [(set_attr "valloc" "macax") + (set_attr "is_g13_muldiv_insn" "yes")] ) ;; start-sanitize-rl78 @@ -731,7 +734,8 @@ movw%H3, ax\n\ ; end of udivmodsi macro"; } - [(set_attr "valloc" "macax")] + [(set_attr "valloc" "macax") + (set_attr "is_g13_muldiv_insn" "yes")] ) (define_insn "mov1" [(set (match_operand:QI 0 "rl78_nonimmediate_operand" "=vU") Index: gcc/config/rl78/rl78.opt =================================================================== --- gcc/config/rl78/rl78.opt(revision 2871) +++ gcc/config/rl78/rl78.opt(working copy) @@ -103,4 +103,10 @@ Target Mask(ES0) Assume ES is zero throughout program execution, use ES: for read-only data. +msave-mduc-in-interrupts +Target Mask(SAVE_MDUC_REGISTERS) +Stores the MDUC registers in interrupt handlers for G13 target. +mno-save-mduc-in-interrupts +Target RejectNegative Mask(NO_SAVE_MDUC_REGISTERS) +Does not save the MDUC registers in interrupt handlers for G13 target. Index: gcc/doc/invoke.texi =================================================================== --- gcc/doc/invoke.texi(revision 2871) +++ gcc/doc/invoke.texi(working copy) @@ -18901,6 +18901,20 @@ registers @code{r24..r31} are reserved for use in interrupt handlers. With this option enabled these registers can be used in ordinary functions as well. + +@item -msave-mduc-in-interrupts +@item -mno-save-mduc-in-interrupts +@opindex msave-mduc-in-interrupts +@opindex mno-save-mduc-in-interrupts +Specifies that interrupt handler functions should preserve the +MDUC registers. This is only necessary if normal code might use +the MDUC registers, for example because it performs multiplication +and division operations. The default is to ignore the MDUC registers +as this makes the interrupt handlers faster. The target option -mg13 +needs to be passed for this to work as this feature is only available +on the G13 target (S2 core). The option will not have any effect if +the target does not have multiply hardware, or if the interrupt +function does not call any other function. @end table @node RS/6000 and PowerPC Options ================== END of Patch ============== -----Original Message----- From: Nick Clifton [mailto:nickc@redhat.com] Sent: Thursday, January 07, 2016 5:33 PM To: Kaushik M Phatak ; dj@redhat.com Cc: Mike Stump ; gcc-patches@gcc.gnu.org; Kaushik Phatak Subject: Re: [PATCH : RL78] Disable interrupts during hardware multiplication routines Hi Kaushik, Just a few comments on the patch itself: --001a113ded4205f3af05291de597 Content-Type: text/plain; charset=US-ASCII; name="rl78_mduc_patch_2.diff" Content-Disposition: attachment; filename="rl78_mduc_patch_2.diff" Content-Transfer-Encoding: base64 X-Attachment-Id: f_ijb2c1ze0 Content-length: 10627 SW5kZXg6IGdjYy9jb25maWcvcmw3OC9ybDc4LmMKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gZ2NjL2NvbmZpZy9ybDc4L3JsNzguYwkocmV2aXNpb24g Mjg3MSkKKysrIGdjYy9jb25maWcvcmw3OC9ybDc4LmMJKHdvcmtpbmcgY29w eSkKQEAgLTgzLDYgKzgzLDIyIEBACiAgICJzcCIsICJhcCIsICJwc3ciLCAi ZXMiLCAiY3MiCiB9OwogCisvKiBTdHJ1Y3R1cmUgZm9yIEcxMyBNRFVDIHJl Z2lzdGVycy4gICovCitzdHJ1Y3QgbWR1Y19yZWdfdHlwZQoreworICB1bnNp Z25lZCBpbnQgYWRkcmVzczsKKyAgZW51bSBtYWNoaW5lX21vZGUgbW9kZTsK KyAgYm9vbCBpc192b2xhdGlsZTsKK307CisKK3N0cnVjdCBtZHVjX3JlZ190 eXBlICBtZHVjX3JlZ3NbTlVNX09GX01EVUNfUkVHU10gPQorICB7ezB4ZjAw ZTgsIFFJbW9kZSwgdHJ1ZX0sCisgICB7MHhmZmZmMCwgSEltb2RlLCB0cnVl fSwKKyAgIHsweGZmZmYyLCBISW1vZGUsIHRydWV9LAorICAgezB4ZjIyMjQs IEhJbW9kZSwgdHJ1ZX0sCisgICB7MHhmMDBlMCwgSEltb2RlLCB0cnVlfSwK KyAgIHsweGYwMGUyLCBISW1vZGUsIHRydWV9fTsKKwogc3RydWN0IEdUWSgo KSkgbWFjaGluZV9mdW5jdGlvbgogewogICAvKiBJZiBzZXQsIHRoZSByZXN0 IG9mIHRoZSBmaWVsZHMgaGF2ZSBiZWVuIGNvbXB1dGVkLiAgKi8KQEAgLTM0 Miw2ICszNTgsMTAgQEAKICN1bmRlZiAgVEFSR0VUX09QVElPTl9PVkVSUklE RQogI2RlZmluZSBUQVJHRVRfT1BUSU9OX09WRVJSSURFCQlybDc4X29wdGlv bl9vdmVycmlkZQogCisjZGVmaW5lIE1VU1RfU0FWRV9NRFVDX1JFR0lTVEVS UyAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICghVEFSR0VUX05PX1NB VkVfTURVQ19SRUdJU1RFUlMgICAgICAgICAgICAgICAgICAgICAgICBcCisg ICAmJiAoaXNfaW50ZXJydXB0X2Z1bmMgKE5VTExfVFJFRSkpICYmIFJMNzhf TVVMX0cxMykKKwogc3RhdGljIHZvaWQKIHJsNzhfb3B0aW9uX292ZXJyaWRl ICh2b2lkKQogewpAQCAtMzY2LDYgKzM4Niw5IEBACiAgICAgLyogQWRkcmVz cyBzcGFjZXMgYXJlIGN1cnJlbnRseSBvbmx5IHN1cHBvcnRlZCBieSBDLiAg Ki8KICAgICBlcnJvciAoIi1tZXMwIGNhbiBvbmx5IGJlIHVzZWQgd2l0aCBD Iik7CiAKKyAgaWYgKFRBUkdFVF9TQVZFX01EVUNfUkVHSVNURVJTICYmICEo VEFSR0VUX0cxMyB8fCBSTDc4X01VTF9HMTMpKQorICAgIHdhcm5pbmcgKDAs ICJtZHVjIHJlZ2lzdGVycyBvbmx5IHNhdmVkIGZvciBHMTMgdGFyZ2V0Iik7 CisKICAgc3dpdGNoIChybDc4X2NwdV90eXBlKQogICAgIHsKICAgICBjYXNl IENQVV9VTklOSVQ6CkBAIC0xMzA3LDYgKzEzMzAsMjMgQEAKICAgcmV0dXJu IChsb29rdXBfYXR0cmlidXRlICgibmFrZWQiLCBERUNMX0FUVFJJQlVURVMg KGN1cnJlbnRfZnVuY3Rpb25fZGVjbCkpICE9IE5VTExfVFJFRSk7CiB9CiAK Ky8qIENoZWNrIGlmIHRoZSBibG9jayB1c2VzIG11bC9kaXYgaW5zbnMgZm9y IEcxMyB0YXJnZXQuICAqLworc3RhdGljIGJvb2wKK2NoZWNrX21kdWNfdXNh Z2UgKCkKK3sKKyAgcnR4IGluc247CisgIGJhc2ljX2Jsb2NrIGJiOworICBG T1JfRUFDSF9CQl9GTiAoYmIsIGNmdW4pCisgIHsKKyAgICBGT1JfQkJfSU5T TlMgKGJiLCBpbnNuKQorICAgIHsKKyAgICAgIGlmIChnZXRfYXR0cl9pc19n MTNfbXVsZGl2X2luc24gKGluc24pID09IElTX0cxM19NVUxESVZfSU5TTl9Z RVMpCisgICAgICAgIHJldHVybiB0cnVlOworICAgIH0KKyAgfQorICByZXR1 cm4gZmFsc2U7Cit9CisKIC8qIEV4cGFuZCB0aGUgZnVuY3Rpb24gcHJvbG9n dWUgKGZyb20gdGhlIHByb2xvZ3VlIHBhdHRlcm4pLiAgKi8KIHZvaWQKIHJs NzhfZXhwYW5kX3Byb2xvZ3VlICh2b2lkKQpAQCAtMTM3MSw2ICsxNDExLDI4 IEBACiAgICAgICBGIChlbWl0X2luc24gKGdlbl9wdXNoIChheCkpKTsKICAg ICB9CiAKKyAgLyogU2F2ZSBNRFVDIHJlZ2lzdGVycyBpbnNpZGUgaW50ZXJy dXB0IHJvdXRpbmUuICAqLworICBpZiAoTVVTVF9TQVZFX01EVUNfUkVHSVNU RVJTICYmICghY3J0bC0+aXNfbGVhZiB8fCBjaGVja19tZHVjX3VzYWdlICgp KSkKKyAgICB7CisgICAgICBydHggbWVtX21kdWM7CisKKyAgICAgIGZvciAo aW50IGkgPSAwOyBpIDxOVU1fT0ZfTURVQ19SRUdTOyBpKyspCisgICAgICB7 CisJaWYgKG1kdWNfcmVnc1tpXS5tb2RlID09IFFJbW9kZSkKKwl7CisJICBt ZW1fbWR1YyA9IGdlbl9ydHhfTUVNIChRSW1vZGUsIEdFTl9JTlQgKG1kdWNf cmVnc1tpXS5hZGRyZXNzKSk7CisJICBNRU1fVk9MQVRJTEVfUCAobWVtX21k dWMpID0gMTsgICAgICAgCisJICBlbWl0X2luc24gKGdlbl9tb3ZxaSAoZ2Vu X3J0eF9SRUcgKFFJbW9kZSwgQV9SRUcpLCBtZW1fbWR1YykpOworCX0KKwll bHNlCisJeworCSAgbWVtX21kdWMgPSBnZW5fcnR4X01FTSAoSEltb2RlLCBH RU5fSU5UIChtZHVjX3JlZ3NbaV0uYWRkcmVzcykpOworCSAgTUVNX1ZPTEFU SUxFX1AgKG1lbV9tZHVjKSA9IDE7ICAgICAgIAorCSAgZW1pdF9pbnNuIChn ZW5fbW92cWkgKGdlbl9ydHhfUkVHIChISW1vZGUsIEFYX1JFRyksIG1lbV9t ZHVjKSk7CisJfQorCWVtaXRfaW5zbiAoZ2VuX3B1c2ggKGdlbl9ydHhfUkVH IChISW1vZGUsIEFYX1JFRykpKTsKKyAgICAgIH0KKyAgICB9CiAgIGlmIChm cmFtZV9wb2ludGVyX25lZWRlZCkKICAgICB7CiAgICAgICBGIChlbWl0X21v dmVfaW5zbiAoYXgsIHNwKSk7CkBAIC0xMzc4LDYgKzE0NDAsOCBAQAogICAg IH0KIAogICBmcyA9IGNmdW4tPm1hY2hpbmUtPmZyYW1lc2l6ZV9sb2NhbHMg KyBjZnVuLT5tYWNoaW5lLT5mcmFtZXNpemVfb3V0Z29pbmc7CisgIGlmIChN VVNUX1NBVkVfTURVQ19SRUdJU1RFUlMgJiYgKCFjcnRsLT5pc19sZWFmIHx8 IGNoZWNrX21kdWNfdXNhZ2UgKCkpKQorICAgIGZzID0gZnMgKyBOVU1fT0Zf TURVQ19SRUdTICogMjsKICAgaWYgKGZzID4gMCkKICAgICB7CiAgICAgICAv KiBJZiB3ZSBuZWVkIHRvIHN1YnRyYWN0IG1vcmUgdGhhbiAyNTQqMyB0aGVu IGl0IGlzIGZhc3RlciBhbmQKQEAgLTE0MjYsNiArMTQ5MCw4IEBACiAgIGVs c2UKICAgICB7CiAgICAgICBmcyA9IGNmdW4tPm1hY2hpbmUtPmZyYW1lc2l6 ZV9sb2NhbHMgKyBjZnVuLT5tYWNoaW5lLT5mcmFtZXNpemVfb3V0Z29pbmc7 CisgICAgICBpZiAoTVVTVF9TQVZFX01EVUNfUkVHSVNURVJTICYmICghY3J0 bC0+aXNfbGVhZiB8fCBjaGVja19tZHVjX3VzYWdlICgpKSkKKwlmcyA9IGZz ICsgTlVNX09GX01EVUNfUkVHUyAqIDI7CiAgICAgICBpZiAoZnMgPiAyNTQg KiAzKQogCXsKIAkgIGVtaXRfbW92ZV9pbnNuIChheCwgc3ApOwpAQCAtMTQ0 NCw2ICsxNTEwLDI5IEBACiAJfQogICAgIH0KIAorICAvKiBSZXN0b3JlIE1E VUMgcmVnaXN0ZXJzIGZyb20gaW50ZXJydXB0IHJvdXRpbmUuICAqLworICBp ZiAoTVVTVF9TQVZFX01EVUNfUkVHSVNURVJTICYmICghY3J0bC0+aXNfbGVh ZiB8fCBjaGVja19tZHVjX3VzYWdlICgpKSkKKyAgICB7CisgICAgICBydHgg bWVtX21kdWM7CisKKyAgICAgIGZvciAoaW50IGkgPSBOVU1fT0ZfTURVQ19S RUdTLTE7IGkgPj0gMDsgaS0tKQorICAgICAgeworCWVtaXRfaW5zbiAoZ2Vu X3BvcCAoZ2VuX3J0eF9SRUcgKEhJbW9kZSwgQVhfUkVHKSkpOworICAgICAg ICBpZiAobWR1Y19yZWdzW2ldLm1vZGUgPT0gUUltb2RlKQorICAgICAgICB7 CisgICAgICAgICAgbWVtX21kdWMgPSBnZW5fcnR4X01FTSAoUUltb2RlLCBH RU5fSU5UIChtZHVjX3JlZ3NbaV0uYWRkcmVzcykpOworICAgICAgICAgIE1F TV9WT0xBVElMRV9QIChtZW1fbWR1YykgPSAxOworCSAgZW1pdF9pbnNuIChn ZW5fbW92cWkgKG1lbV9tZHVjLCBnZW5fcnR4X1JFRyAoUUltb2RlLCBBX1JF RykpKTsKKyAgICAgICAgfQorICAgICAgICBlbHNlCisgICAgICAgIHsKKyAg ICAgICAgICBtZW1fbWR1YyA9IGdlbl9ydHhfTUVNIChISW1vZGUsIEdFTl9J TlQgKG1kdWNfcmVnc1tpXS5hZGRyZXNzKSk7CisgICAgICAgICAgTUVNX1ZP TEFUSUxFX1AgKG1lbV9tZHVjKSA9IDE7CisJICBlbWl0X2luc24gKGdlbl9t b3ZoaSAobWVtX21kdWMsIGdlbl9ydHhfUkVHIChISW1vZGUsIEFYX1JFRykp KTsKKyAgICAgICAgfQorICAgICAgfQorICAgIH0KKwogICAvKiBTYXZlIEVT IHJlZ2lzdGVyIGluc2lkZSBpbnRlcnJ1cHQgZnVuY3Rpb25zLiAgKi8KICAg aWYgKGlzX2ludGVycnVwdF9mdW5jIChjZnVuLT5kZWNsKSAmJiBjZnVuLT5t YWNoaW5lLT51c2VzX2VzKQogICAgIHsKQEAgLTE1OTksNiArMTY4OCw5IEBA CiAKICAgaWYgKGNmdW4tPm1hY2hpbmUtPnVzZXNfZXMpCiAgICAgZnByaW50 ZiAoZmlsZSwgIlx0OyB1c2VzIEVTIHJlZ2lzdGVyXG4iKTsKKworICBpZiAo TVVTVF9TQVZFX01EVUNfUkVHSVNURVJTKQorICAgIGZwcmludGYgKGZpbGUs ICJcdDsgcHJlc2VydmVzIE1EVUMgcmVnaXN0ZXJzXG4iKTsKIH0KIAogLyog UmV0dXJuIGFuIFJUTCBkZXNjcmliaW5nIHdoZXJlIGEgZnVuY3Rpb24gcmV0 dXJuIHZhbHVlIG9mIHR5cGUgUkVUX1RZUEUKSW5kZXg6IGdjYy9jb25maWcv cmw3OC9ybDc4LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gZ2NjL2Nv bmZpZy9ybDc4L3JsNzguaAkocmV2aXNpb24gMjg3MSkKKysrIGdjYy9jb25m aWcvcmw3OC9ybDc4LmgJKHdvcmtpbmcgY29weSkKQEAgLTI4LDYgKzI4LDcg QEAKICNkZWZpbmUgVEFSR0VUX0cxNAkocmw3OF9jcHVfdHlwZSA9PSBDUFVf RzE0KQogCiAKKyNkZWZpbmUgTlVNX09GX01EVUNfUkVHUyA2CiAKICNkZWZp bmUgVEFSR0VUX0NQVV9DUFBfQlVJTFRJTlMoKQkJICAgIFwKICAgZG8gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CkluZGV4OiBnY2MvY29uZmlnL3JsNzgvcmw3OC5tZAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBnY2MvY29uZmlnL3JsNzgvcmw3OC5tZAkocmV2aXNp b24gMjg3MSkKKysrIGdjYy9jb25maWcvcmw3OC9ybDc4Lm1kCSh3b3JraW5n IGNvcHkpCkBAIC03OCw2ICs3OCw3IEBACiAoaW5jbHVkZSAicmw3OC12aXJ0 Lm1kIikKIChpbmNsdWRlICJybDc4LXJlYWwubWQiKQogCisoZGVmaW5lX2F0 dHIgImlzX2cxM19tdWxkaXZfaW5zbiIgInllcyxubyIgKGNvbnN0X3N0cmlu ZyAibm8iKSkKIAogOzsgRnVuY3Rpb24gUHJvbG9ndWUvRXBpbG9ndWUgSW5z dHJ1Y3Rpb25zCiAKQEAgLTQxNiw3ICs0MTcsOCBAQAogCW1vdncgICAgYXgs IDB4ZmZmZjYgICAgIDsgTURCTAogCW1vdncgICAgJWgwLCBheAogICAgICAg ICA7IGVuZCBvZiBtdWxoaSBtYWNybyIKLSAgWyhzZXRfYXR0ciAidmFsbG9j IiAibWFjYXgiKV0KKyAgWyhzZXRfYXR0ciAidmFsbG9jIiAibWFjYXgiKQor ICAgKHNldF9hdHRyICJpc19nMTNfbXVsZGl2X2luc24iICJ5ZXMiKV0KICkK IAogOzsgMHhGRkZGMCBpcyBNQUNSKEwpLiAgMHhGRkZGMiBpcyBNQUNSKEgp IGJ1dCB3ZSBkb24ndCBjYXJlIGFib3V0IGl0CkBAIC00OTYsNyArNDk4LDgg QEAKIAltb3Z3CWF4LCAhMHhmMDBlMAk7IE1EQ0wKIAltb3Z3CSVIMCwgYXgK IAk7IGVuZCBvZiBtdWxzaSBtYWNybyIKLSAgWyhzZXRfYXR0ciAidmFsbG9j IiAibWFjYXgiKV0KKyAgWyhzZXRfYXR0ciAidmFsbG9jIiAibWFjYXgiKQor ICAgKHNldF9hdHRyICJpc19nMTNfbXVsZGl2X2luc24iICJ5ZXMiKV0KICkK IAogOzsgc3RhcnQtc2FuaXRpemUtcmw3OApAQCAtNzMxLDcgKzczNCw4IEBA CiAJbW92dwklSDMsIGF4CQlcblwKIAk7IGVuZCBvZiB1ZGl2bW9kc2kgbWFj cm8iOwogICAgICAgfQotICBbKHNldF9hdHRyICJ2YWxsb2MiICJtYWNheCIp XQorICBbKHNldF9hdHRyICJ2YWxsb2MiICJtYWNheCIpCisgICAoc2V0X2F0 dHIgImlzX2cxM19tdWxkaXZfaW5zbiIgInllcyIpXQogKQogKGRlZmluZV9p bnNuICJtb3YxIgogICBbKHNldCAobWF0Y2hfb3BlcmFuZDpRSSAgICAgICAg IDAgInJsNzhfbm9uaW1tZWRpYXRlX29wZXJhbmQiICAgIj12VSIpCkluZGV4 OiBnY2MvY29uZmlnL3JsNzgvcmw3OC5vcHQKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gZ2NjL2NvbmZpZy9ybDc4L3JsNzgub3B0CShyZXZpc2lvbiAy ODcxKQorKysgZ2NjL2NvbmZpZy9ybDc4L3JsNzgub3B0CSh3b3JraW5nIGNv cHkpCkBAIC0xMDMsNCArMTAzLDEwIEBACiBUYXJnZXQgTWFzayhFUzApCiBB c3N1bWUgRVMgaXMgemVybyB0aHJvdWdob3V0IHByb2dyYW0gZXhlY3V0aW9u LCB1c2UgRVM6IGZvciByZWFkLW9ubHkgZGF0YS4KIAorbXNhdmUtbWR1Yy1p bi1pbnRlcnJ1cHRzCitUYXJnZXQgTWFzayhTQVZFX01EVUNfUkVHSVNURVJT KQorU3RvcmVzIHRoZSBNRFVDIHJlZ2lzdGVycyBpbiBpbnRlcnJ1cHQgaGFu ZGxlcnMgZm9yIEcxMyB0YXJnZXQuCiAKK21uby1zYXZlLW1kdWMtaW4taW50 ZXJydXB0cworVGFyZ2V0IFJlamVjdE5lZ2F0aXZlIE1hc2soTk9fU0FWRV9N RFVDX1JFR0lTVEVSUykKK0RvZXMgbm90IHNhdmUgdGhlIE1EVUMgcmVnaXN0 ZXJzIGluIGludGVycnVwdCBoYW5kbGVycyBmb3IgRzEzIHRhcmdldC4KSW5k ZXg6IGdjYy9kb2MvaW52b2tlLnRleGkKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gZ2NjL2RvYy9pbnZva2UudGV4aQkocmV2aXNpb24gMjg3MSkKKysr IGdjYy9kb2MvaW52b2tlLnRleGkJKHdvcmtpbmcgY29weSkKQEAgLTE4OTAx LDYgKzE4OTAxLDIwIEBACiByZWdpc3RlcnMgQGNvZGV7cjI0Li5yMzF9IGFy ZSByZXNlcnZlZCBmb3IgdXNlIGluIGludGVycnVwdCBoYW5kbGVycy4KIFdp dGggdGhpcyBvcHRpb24gZW5hYmxlZCB0aGVzZSByZWdpc3RlcnMgY2FuIGJl IHVzZWQgaW4gb3JkaW5hcnkKIGZ1bmN0aW9ucyBhcyB3ZWxsLgorCitAaXRl bSAtbXNhdmUtbWR1Yy1pbi1pbnRlcnJ1cHRzCitAaXRlbSAtbW5vLXNhdmUt bWR1Yy1pbi1pbnRlcnJ1cHRzCitAb3BpbmRleCBtc2F2ZS1tZHVjLWluLWlu dGVycnVwdHMKK0BvcGluZGV4IG1uby1zYXZlLW1kdWMtaW4taW50ZXJydXB0 cworU3BlY2lmaWVzIHRoYXQgaW50ZXJydXB0IGhhbmRsZXIgZnVuY3Rpb25z IHNob3VsZCBwcmVzZXJ2ZSB0aGUKK01EVUMgcmVnaXN0ZXJzLiAgVGhpcyBp cyBvbmx5IG5lY2Vzc2FyeSBpZiBub3JtYWwgY29kZSBtaWdodCB1c2UKK3Ro ZSBNRFVDIHJlZ2lzdGVycywgZm9yIGV4YW1wbGUgYmVjYXVzZSBpdCBwZXJm b3JtcyBtdWx0aXBsaWNhdGlvbgorYW5kIGRpdmlzaW9uIG9wZXJhdGlvbnMu IFRoZSBkZWZhdWx0IGlzIHRvIGlnbm9yZSB0aGUgTURVQyByZWdpc3RlcnMK K2FzIHRoaXMgbWFrZXMgdGhlIGludGVycnVwdCBoYW5kbGVycyBmYXN0ZXIu IFRoZSB0YXJnZXQgb3B0aW9uIC1tZzEzCituZWVkcyB0byBiZSBwYXNzZWQg Zm9yIHRoaXMgdG8gd29yayBhcyB0aGlzIGZlYXR1cmUgaXMgb25seSBhdmFp bGFibGUKK29uIHRoZSBHMTMgdGFyZ2V0IChTMiBjb3JlKS4gVGhlIG9wdGlv biB3aWxsIG5vdCBoYXZlIGFueSBlZmZlY3QgaWYKK3RoZSB0YXJnZXQgZG9l cyBub3QgaGF2ZSBtdWx0aXBseSBoYXJkd2FyZSwgb3IgaWYgdGhlIGludGVy cnVwdAorZnVuY3Rpb24gZG9lcyBub3QgY2FsbCBhbnkgb3RoZXIgZnVuY3Rp b24uCiBAZW5kIHRhYmxlCiAKIEBub2RlIFJTLzYwMDAgYW5kIFBvd2VyUEMg T3B0aW9ucwo= --001a113ded4205f3af05291de597--