From 0d37e2d3ead072ba57e03fcb97a041504a22e721 Mon Sep 17 00:00:00 2001 From: Vladimir Makarov Date: Fri, 26 Mar 2021 17:09:24 +0000 Subject: [PR99766] Consider relaxed memory associated more with memory instead of special memory. Relaxed memory should be considered more like memory then special memory. gcc/ChangeLog: PR target/99766 * ira-costs.c (record_reg_classes): Put case with CT_RELAXED_MEMORY adjacent to one with CT_MEMORY. * ira.c (ira_setup_alts): Ditto. * lra-constraints.c (process_alt_operands): Ditto. * recog.c (asm_operand_ok): Ditto. * reload.c (find_reloads): Ditto. gcc/testsuite/ChangeLog: PR target/99766 * g++.target/aarch64/sve/pr99766.C: New. --- gcc/recog.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'gcc/recog.c') diff --git a/gcc/recog.c b/gcc/recog.c index ee143bc..eb617f1 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -2267,10 +2267,10 @@ asm_operand_ok (rtx op, const char *constraint, const char **constraints) break; case CT_MEMORY: + case CT_RELAXED_MEMORY: mem = op; /* Fall through. */ case CT_SPECIAL_MEMORY: - case CT_RELAXED_MEMORY: /* Every memory operand can be reloaded to fit. */ if (!mem) mem = extract_mem_from_operand (op); -- cgit v1.1 From a86b3453fc6e29cf0e19916b01c393652d838d56 Mon Sep 17 00:00:00 2001 From: Uros Bizjak Date: Thu, 1 Jul 2021 15:18:50 +0200 Subject: Change the type of predicates to bool. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The patch was tested on many targets, but some fallout is expected. To fix the build error, simply change the function type from int to bool, as was done in the patch for several targets. 2021-07-01 Uroš Bizjak gcc/ * genpreds.c (write_predicate_subfunction): Change the type of written subfunction to bool. (write_one_predicate_function): Change the type of written function to bool. (write_tm_preds_h): Ditto. * recog.h (*insn_operand_predicate_fn): Change the type to bool. * recog.c (general_operand): Change the type to bool. (address_operand): Ditto. (register_operand): Ditto. (pmode_register_operand): Ditto. (scratch_operand): Ditto. (immediate_operand): Ditto. (const_int_operand): Ditto. (const_scalar_int_operand): Ditto. (const_double_operand): Ditto. (nonimmediate_operand): Ditto. (nonmemory_operand): Ditto. (push_operand): Ditto. (pop_operand): Ditto. (memory_operand): Ditto. (indirect_operand): Ditto. (ordered_comparison_operator): Ditto. (comparison_operator): Ditto. * config/i386/i386-expand.c (ix86_expand_sse_cmp): Change the type of indirect predicate function to bool. * config/rs6000/rs6000.c (easy_vector_constant): Change the type to bool. * config/mips/mips-protos.h (m16_based_address_p): Change the type of operand 3 to bool. --- gcc/recog.c | 73 +++++++++++++++++++++++++++++++------------------------------ 1 file changed, 37 insertions(+), 36 deletions(-) (limited to 'gcc/recog.c') diff --git a/gcc/recog.c b/gcc/recog.c index eb617f1..9d88043 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -1393,7 +1393,7 @@ valid_insn_p (rtx_insn *insn) return true; } -/* Return 1 if OP is a valid general operand for machine mode MODE. +/* Return true if OP is a valid general operand for machine mode MODE. This is either a register reference, a memory reference, or a constant. In the case of a memory reference, the address is checked for general validity for the target machine. @@ -1407,7 +1407,7 @@ valid_insn_p (rtx_insn *insn) The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool general_operand (rtx op, machine_mode mode) { enum rtx_code code = GET_CODE (op); @@ -1515,13 +1515,13 @@ general_operand (rtx op, machine_mode mode) return 0; } -/* Return 1 if OP is a valid memory address for a memory reference +/* Return true if OP is a valid memory address for a memory reference of mode MODE. The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool address_operand (rtx op, machine_mode mode) { /* Wrong mode for an address expr. */ @@ -1532,13 +1532,13 @@ address_operand (rtx op, machine_mode mode) return memory_address_p (mode, op); } -/* Return 1 if OP is a register reference of mode MODE. +/* Return true if OP is a register reference of mode MODE. If MODE is VOIDmode, accept a register in any mode. The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool register_operand (rtx op, machine_mode mode) { if (GET_CODE (op) == SUBREG) @@ -1559,18 +1559,18 @@ register_operand (rtx op, machine_mode mode) return general_operand (op, mode); } -/* Return 1 for a register in Pmode; ignore the tested mode. */ +/* Return true for a register in Pmode; ignore the tested mode. */ -int +bool pmode_register_operand (rtx op, machine_mode mode ATTRIBUTE_UNUSED) { return register_operand (op, Pmode); } -/* Return 1 if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH +/* Return true if OP should match a MATCH_SCRATCH, i.e., if it is a SCRATCH or a hard register. */ -int +bool scratch_operand (rtx op, machine_mode mode) { if (GET_MODE (op) != mode && mode != VOIDmode) @@ -1583,12 +1583,12 @@ scratch_operand (rtx op, machine_mode mode) && REGNO_REG_CLASS (REGNO (op)) != NO_REGS)))); } -/* Return 1 if OP is a valid immediate operand for mode MODE. +/* Return true if OP is a valid immediate operand for mode MODE. The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool immediate_operand (rtx op, machine_mode mode) { /* Don't accept CONST_INT or anything similar @@ -1612,9 +1612,9 @@ immediate_operand (rtx op, machine_mode mode) : mode, op)); } -/* Returns 1 if OP is an operand that is a CONST_INT of mode MODE. */ +/* Return true if OP is an operand that is a CONST_INT of mode MODE. */ -int +bool const_int_operand (rtx op, machine_mode mode) { if (!CONST_INT_P (op)) @@ -1628,9 +1628,9 @@ const_int_operand (rtx op, machine_mode mode) } #if TARGET_SUPPORTS_WIDE_INT -/* Returns 1 if OP is an operand that is a CONST_INT or CONST_WIDE_INT +/* Return true if OP is an operand that is a CONST_INT or CONST_WIDE_INT of mode MODE. */ -int +bool const_scalar_int_operand (rtx op, machine_mode mode) { if (!CONST_SCALAR_INT_P (op)) @@ -1661,20 +1661,20 @@ const_scalar_int_operand (rtx op, machine_mode mode) return 1; } -/* Returns 1 if OP is an operand that is a constant integer or constant +/* Return true if OP is an operand that is a constant integer or constant floating-point number of MODE. */ -int +bool const_double_operand (rtx op, machine_mode mode) { return (GET_CODE (op) == CONST_DOUBLE) && (GET_MODE (op) == mode || mode == VOIDmode); } #else -/* Returns 1 if OP is an operand that is a constant integer or constant +/* Return true if OP is an operand that is a constant integer or constant floating-point number of MODE. */ -int +bool const_double_operand (rtx op, machine_mode mode) { /* Don't accept CONST_INT or anything similar @@ -1689,18 +1689,19 @@ const_double_operand (rtx op, machine_mode mode) || GET_MODE (op) == VOIDmode)); } #endif -/* Return 1 if OP is a general operand that is not an immediate +/* Return true if OP is a general operand that is not an immediate operand of mode MODE. */ -int +bool nonimmediate_operand (rtx op, machine_mode mode) { return (general_operand (op, mode) && ! CONSTANT_P (op)); } -/* Return 1 if OP is a register reference or immediate value of mode MODE. */ +/* Return true if OP is a register reference or + immediate value of mode MODE. */ -int +bool nonmemory_operand (rtx op, machine_mode mode) { if (CONSTANT_P (op)) @@ -1708,13 +1709,13 @@ nonmemory_operand (rtx op, machine_mode mode) return register_operand (op, mode); } -/* Return 1 if OP is a valid operand that stands for pushing a +/* Return true if OP is a valid operand that stands for pushing a value of mode MODE onto the stack. The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool push_operand (rtx op, machine_mode mode) { if (!MEM_P (op)) @@ -1752,13 +1753,13 @@ push_operand (rtx op, machine_mode mode) return XEXP (op, 0) == stack_pointer_rtx; } -/* Return 1 if OP is a valid operand that stands for popping a +/* Return true if OP is a valid operand that stands for popping a value of mode MODE off the stack. The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool pop_operand (rtx op, machine_mode mode) { if (!MEM_P (op)) @@ -1794,13 +1795,13 @@ memory_address_addr_space_p (machine_mode mode ATTRIBUTE_UNUSED, #endif } -/* Return 1 if OP is a valid memory reference with mode MODE, +/* Return true if OP is a valid memory reference with mode MODE, including a valid address. The main use of this function is as a predicate in match_operand expressions in the machine description. */ -int +bool memory_operand (rtx op, machine_mode mode) { rtx inner; @@ -1820,10 +1821,10 @@ memory_operand (rtx op, machine_mode mode) return (MEM_P (inner) && general_operand (op, mode)); } -/* Return 1 if OP is a valid indirect memory reference with mode MODE; +/* Return true if OP is a valid indirect memory reference with mode MODE; that is, a memory reference whose address is a general_operand. */ -int +bool indirect_operand (rtx op, machine_mode mode) { /* Before reload, a SUBREG isn't in memory (see memory_operand, above). */ @@ -1848,10 +1849,10 @@ indirect_operand (rtx op, machine_mode mode) && general_operand (XEXP (op, 0), Pmode)); } -/* Return 1 if this is an ordered comparison operator (not including +/* Return true if this is an ordered comparison operator (not including ORDERED and UNORDERED). */ -int +bool ordered_comparison_operator (rtx op, machine_mode mode) { if (mode != VOIDmode && GET_MODE (op) != mode) @@ -1874,10 +1875,10 @@ ordered_comparison_operator (rtx op, machine_mode mode) } } -/* Return 1 if this is a comparison operator. This allows the use of +/* Return true if this is a comparison operator. This allows the use of MATCH_OPERATOR to recognize all the branch insns. */ -int +bool comparison_operator (rtx op, machine_mode mode) { return ((mode == VOIDmode || GET_MODE (op) == mode) -- cgit v1.1 From cfeffe9c461762bf95ba63dce535c81ddb36f109 Mon Sep 17 00:00:00 2001 From: Uros Bizjak Date: Thu, 1 Jul 2021 16:52:11 +0200 Subject: Return true/false instead of 1/0 from generic predicates. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit No functional changes. 2021-07-01 Uroš Bizjak gcc/ * recog.c (general_operand): Return true/false instead of 1/0. (register_operand): Ditto. (immediate_operand): Ditto. (const_int_operand): Ditto. (const_scalar_int_operand): Ditto. (const_double_operand): Ditto. (push_operand): Ditto. (pop_operand): Ditto. (memory_operand): Ditto. (indirect_operand): Ditto. --- gcc/recog.c | 64 ++++++++++++++++++++++++++++++------------------------------- 1 file changed, 32 insertions(+), 32 deletions(-) (limited to 'gcc/recog.c') diff --git a/gcc/recog.c b/gcc/recog.c index 9d88043..2114df8 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -1420,12 +1420,12 @@ general_operand (rtx op, machine_mode mode) if (GET_MODE (op) == VOIDmode && mode != VOIDmode && GET_MODE_CLASS (mode) != MODE_INT && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT) - return 0; + return false; if (CONST_INT_P (op) && mode != VOIDmode && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op)) - return 0; + return false; if (CONSTANT_P (op)) return ((GET_MODE (op) == VOIDmode || GET_MODE (op) == mode @@ -1439,7 +1439,7 @@ general_operand (rtx op, machine_mode mode) OP's mode must match MODE if MODE specifies a mode. */ if (GET_MODE (op) != mode) - return 0; + return false; if (code == SUBREG) { @@ -1452,7 +1452,7 @@ general_operand (rtx op, machine_mode mode) get cleaned up by cleanup_subreg_operands. */ if (!reload_completed && MEM_P (sub) && paradoxical_subreg_p (op)) - return 0; + return false; #endif /* Avoid memories with nonzero SUBREG_BYTE, as offsetting the memory may result in incorrect reference. We should simplify all valid @@ -1463,7 +1463,7 @@ general_operand (rtx op, machine_mode mode) if (!reload_completed && maybe_ne (SUBREG_BYTE (op), 0) && MEM_P (sub)) - return 0; + return false; if (REG_P (sub) && REGNO (sub) < FIRST_PSEUDO_REGISTER @@ -1474,7 +1474,7 @@ general_operand (rtx op, machine_mode mode) operand reload presentation. LRA needs to treat them as valid. */ && ! LRA_SUBREG_P (op)) - return 0; + return false; /* FLOAT_MODE subregs can't be paradoxical. Combine will occasionally create such rtl, and we must reject it. */ @@ -1486,7 +1486,7 @@ general_operand (rtx op, machine_mode mode) mode. */ && ! lra_in_progress && paradoxical_subreg_p (op)) - return 0; + return false; op = sub; code = GET_CODE (op); @@ -1501,7 +1501,7 @@ general_operand (rtx op, machine_mode mode) rtx y = XEXP (op, 0); if (! volatile_ok && MEM_VOLATILE_P (op)) - return 0; + return false; /* Use the mem's mode, since it will be reloaded thus. LRA can generate move insn with invalid addresses which is made valid @@ -1509,10 +1509,10 @@ general_operand (rtx op, machine_mode mode) transformations. */ if (lra_in_progress || memory_address_addr_space_p (GET_MODE (op), y, MEM_ADDR_SPACE (op))) - return 1; + return true; } - return 0; + return false; } /* Return true if OP is a valid memory address for a memory reference @@ -1552,10 +1552,10 @@ register_operand (rtx op, machine_mode mode) but currently it does result from (SUBREG (REG)...) where the reg went on the stack.) */ if (!REG_P (sub) && (reload_completed || !MEM_P (sub))) - return 0; + return false; } else if (!REG_P (op)) - return 0; + return false; return general_operand (op, mode); } @@ -1574,7 +1574,7 @@ bool scratch_operand (rtx op, machine_mode mode) { if (GET_MODE (op) != mode && mode != VOIDmode) - return 0; + return false; return (GET_CODE (op) == SCRATCH || (REG_P (op) @@ -1596,12 +1596,12 @@ immediate_operand (rtx op, machine_mode mode) if (GET_MODE (op) == VOIDmode && mode != VOIDmode && GET_MODE_CLASS (mode) != MODE_INT && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT) - return 0; + return false; if (CONST_INT_P (op) && mode != VOIDmode && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op)) - return 0; + return false; return (CONSTANT_P (op) && (GET_MODE (op) == mode || mode == VOIDmode @@ -1618,13 +1618,13 @@ bool const_int_operand (rtx op, machine_mode mode) { if (!CONST_INT_P (op)) - return 0; + return false; if (mode != VOIDmode && trunc_int_for_mode (INTVAL (op), mode) != INTVAL (op)) - return 0; + return false; - return 1; + return true; } #if TARGET_SUPPORTS_WIDE_INT @@ -1634,7 +1634,7 @@ bool const_scalar_int_operand (rtx op, machine_mode mode) { if (!CONST_SCALAR_INT_P (op)) - return 0; + return false; if (CONST_INT_P (op)) return const_int_operand (op, mode); @@ -1646,10 +1646,10 @@ const_scalar_int_operand (rtx op, machine_mode mode) int bitsize = GET_MODE_BITSIZE (int_mode); if (CONST_WIDE_INT_NUNITS (op) * HOST_BITS_PER_WIDE_INT > bitsize) - return 0; + return false; if (prec == bitsize) - return 1; + return true; else { /* Multiword partial int. */ @@ -1658,7 +1658,7 @@ const_scalar_int_operand (rtx op, machine_mode mode) return (sext_hwi (x, prec & (HOST_BITS_PER_WIDE_INT - 1)) == x); } } - return 1; + return true; } /* Return true if OP is an operand that is a constant integer or constant @@ -1682,7 +1682,7 @@ const_double_operand (rtx op, machine_mode mode) if (GET_MODE (op) == VOIDmode && mode != VOIDmode && GET_MODE_CLASS (mode) != MODE_INT && GET_MODE_CLASS (mode) != MODE_PARTIAL_INT) - return 0; + return false; return ((CONST_DOUBLE_P (op) || CONST_INT_P (op)) && (mode == VOIDmode || GET_MODE (op) == mode @@ -1719,10 +1719,10 @@ bool push_operand (rtx op, machine_mode mode) { if (!MEM_P (op)) - return 0; + return false; if (mode != VOIDmode && GET_MODE (op) != mode) - return 0; + return false; poly_int64 rounded_size = GET_MODE_SIZE (mode); @@ -1735,7 +1735,7 @@ push_operand (rtx op, machine_mode mode) if (known_eq (rounded_size, GET_MODE_SIZE (mode))) { if (GET_CODE (op) != STACK_PUSH_CODE) - return 0; + return false; } else { @@ -1747,7 +1747,7 @@ push_operand (rtx op, machine_mode mode) || (STACK_GROWS_DOWNWARD ? maybe_ne (offset, -rounded_size) : maybe_ne (offset, rounded_size))) - return 0; + return false; } return XEXP (op, 0) == stack_pointer_rtx; @@ -1763,15 +1763,15 @@ bool pop_operand (rtx op, machine_mode mode) { if (!MEM_P (op)) - return 0; + return false; if (mode != VOIDmode && GET_MODE (op) != mode) - return 0; + return false; op = XEXP (op, 0); if (GET_CODE (op) != STACK_POP_CODE) - return 0; + return false; return XEXP (op, 0) == stack_pointer_rtx; } @@ -1812,7 +1812,7 @@ memory_operand (rtx op, machine_mode mode) return MEM_P (op) && general_operand (op, mode); if (mode != VOIDmode && GET_MODE (op) != mode) - return 0; + return false; inner = op; if (GET_CODE (inner) == SUBREG) @@ -1832,7 +1832,7 @@ indirect_operand (rtx op, machine_mode mode) && GET_CODE (op) == SUBREG && MEM_P (SUBREG_REG (op))) { if (mode != VOIDmode && GET_MODE (op) != mode) - return 0; + return false; /* The only way that we can have a general_operand as the resulting address is if OFFSET is zero and the address already is an operand -- cgit v1.1 From fe610051a803131822bd02a8842a67b573b8e46a Mon Sep 17 00:00:00 2001 From: Uros Bizjak Date: Mon, 12 Jul 2021 16:34:41 +0200 Subject: Change the type of memory classification functions to bool MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 2021-07-12 Uroš Bizjak gcc/ * recog.c (memory_address_addr_space_p): Change the type to bool. Return true/false instead of 1/0. (offsettable_memref_p): Ditto. (offsettable_nonstrict_memref_p): Ditto. (offsettable_address_addr_space_p): Ditto. Change the type of addressp indirect function to bool. * recog.h (memory_address_addr_space_p): Change the type to bool. (strict_memory_address_addr_space_p): Ditto. (offsettable_memref_p): Ditto. (offsettable_nonstrict_memref_p): Ditto. (offsettable_address_addr_space_p): Ditto. * reload.c (maybe_memory_address_addr_space_p): Ditto. (strict_memory_address_addr_space_p): Change the type to bool. Return true/false instead of 1/0. (maybe_memory_address_addr_space_p): Change the type to bool. --- gcc/recog.c | 36 +++++++++++++++++------------------- 1 file changed, 17 insertions(+), 19 deletions(-) (limited to 'gcc/recog.c') diff --git a/gcc/recog.c b/gcc/recog.c index 2114df8..5a42c45 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -1776,20 +1776,20 @@ pop_operand (rtx op, machine_mode mode) return XEXP (op, 0) == stack_pointer_rtx; } -/* Return 1 if ADDR is a valid memory address +/* Return true if ADDR is a valid memory address for mode MODE in address space AS. */ -int +bool memory_address_addr_space_p (machine_mode mode ATTRIBUTE_UNUSED, rtx addr, addr_space_t as) { #ifdef GO_IF_LEGITIMATE_ADDRESS gcc_assert (ADDR_SPACE_GENERIC_P (as)); GO_IF_LEGITIMATE_ADDRESS (mode, addr, win); - return 0; + return false; win: - return 1; + return true; #else return targetm.addr_space.legitimate_address_p (mode, addr, 0, as); #endif @@ -2361,18 +2361,16 @@ find_constant_term_loc (rtx *p) return 0; } -/* Return 1 if OP is a memory reference - whose address contains no side effects - and remains valid after the addition - of a positive integer less than the - size of the object being referenced. +/* Return true if OP is a memory reference whose address contains + no side effects and remains valid after the addition of a positive + integer less than the size of the object being referenced. We assume that the original address is valid and do not check it. This uses strict_memory_address_p as a subroutine, so don't use it before reload. */ -int +bool offsettable_memref_p (rtx op) { return ((MEM_P (op)) @@ -2383,7 +2381,7 @@ offsettable_memref_p (rtx op) /* Similar, but don't require a strictly valid mem ref: consider pseudo-regs valid as index or base regs. */ -int +bool offsettable_nonstrict_memref_p (rtx op) { return ((MEM_P (op)) @@ -2391,7 +2389,7 @@ offsettable_nonstrict_memref_p (rtx op) MEM_ADDR_SPACE (op))); } -/* Return 1 if Y is a memory address which contains no side effects +/* Return true if Y is a memory address which contains no side effects and would remain valid for address space AS after the addition of a positive integer less than the size of that mode. @@ -2401,7 +2399,7 @@ offsettable_nonstrict_memref_p (rtx op) If STRICTP is nonzero, we require a strictly valid address, for the sake of use in reload.c. */ -int +bool offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y, addr_space_t as) { @@ -2409,19 +2407,19 @@ offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y, rtx z; rtx y1 = y; rtx *y2; - int (*addressp) (machine_mode, rtx, addr_space_t) = + bool (*addressp) (machine_mode, rtx, addr_space_t) = (strictp ? strict_memory_address_addr_space_p : memory_address_addr_space_p); poly_int64 mode_sz = GET_MODE_SIZE (mode); if (CONSTANT_ADDRESS_P (y)) - return 1; + return true; /* Adjusting an offsettable address involves changing to a narrower mode. Make sure that's OK. */ if (mode_dependent_address_p (y, as)) - return 0; + return false; machine_mode address_mode = GET_MODE (y); if (address_mode == VOIDmode) @@ -2442,7 +2440,7 @@ offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y, if ((ycode == PLUS) && (y2 = find_constant_term_loc (&y1))) { - int good; + bool good; y1 = *y2; *y2 = plus_constant (address_mode, *y2, mode_sz - 1); @@ -2456,7 +2454,7 @@ offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y, } if (GET_RTX_CLASS (ycode) == RTX_AUTOINC) - return 0; + return false; /* The offset added here is chosen as the maximum offset that any instruction could need to add when operating on something @@ -2486,7 +2484,7 @@ offsettable_address_addr_space_p (int strictp, machine_mode mode, rtx y, return (*addressp) (QImode, z, as); } -/* Return 1 if ADDR is an address-expression whose effect depends +/* Return true if ADDR is an address-expression whose effect depends on the mode of the memory reference it is used in. ADDRSPACE is the address space associated with the address. -- cgit v1.1