Attachment #35281 for bug #57032

View | Details | Return to bug 57032
Collapse All | Expand All

Lines 10110-10115 Link Here

(-)alpha.c (+3 lines)
10110	#undef TARGET_LEGITIMATE_ADDRESS_P	10110	#undef TARGET_LEGITIMATE_ADDRESS_P
10111	#define TARGET_LEGITIMATE_ADDRESS_P alpha_legitimate_address_p	10111	#define TARGET_LEGITIMATE_ADDRESS_P alpha_legitimate_address_p
10112		10112
		10113	#undef TARGET_LRA_P
		10114	#define TARGET_LRA_P hook_bool_void_true
		10115
10113	#undef TARGET_CONDITIONAL_REGISTER_USAGE	10116	#undef TARGET_CONDITIONAL_REGISTER_USAGE
10114	#define TARGET_CONDITIONAL_REGISTER_USAGE alpha_conditional_register_usage	10117	#define TARGET_CONDITIONAL_REGISTER_USAGE alpha_conditional_register_usage
10115		10118

Lines 97-105 Link Here

(-)constraints.md (-3 / +6 lines)
97	&& op == CONST0_RTX (mode)")))	97	&& op == CONST0_RTX (mode)")))
98		98
99	;; "Extra" constraints.	99	;; "Extra" constraints.
100	(define_constraint "Q"	100	(define_memory_constraint "Q"
101	"@internal A normal_memory_operand"	101	"@internal normal memory operand"
102	(match_operand 0 "normal_memory_operand"))	102	(and (match_code "mem")
		103	(match_test "GET_CODE (XEXP (op, 0)) != AND")
		104	(match_test "memory_address_addr_space_p
		105	(GET_MODE (op), XEXP (op, 0), MEM_ADDR_SPACE (op))")))
103		106
104	(define_constraint "R"	107	(define_constraint "R"
105	"@internal A direct_call_operand"	108	"@internal A direct_call_operand"




;; pessimizes things a tad.

(define_special_predicate "aligned_memory_operand"
  (match_code "mem")
       (match_code "mem"))
{
  rtx base;
  int offset;

;; Similar, but return 1 if OP is a MEM which is not alignable.

(define_special_predicate "unaligned_memory_operand"
  (match_code "mem")
       (match_code "mem"))
{
  rtx base;
  int offset;

  return false;
})

;; Return 1 is OP is a memory location that is not a reference
;; (using an AND) to an unaligned location.  Take into account
;; what reload will do.
(define_special_predicate "normal_memory_operand"
  (ior (match_test "op = resolve_reload_operand (op), 0")
       (and (match_code "mem")
	    (match_test "GET_CODE (XEXP (op, 0)) != AND"))))

;; Returns 1 if OP is not an eliminable register.
;;
;; This exists to cure a pathological failure in the s8addq (et al) patterns,

Return to bug 57032

Lines 441-448 Link Here

(-)predicates.md (-12 / +2 lines)
441	;; pessimizes things a tad.	441	;; pessimizes things a tad.
442		442
443	(define_special_predicate "aligned_memory_operand"	443	(define_special_predicate "aligned_memory_operand"
444	(ior (match_test "op = resolve_reload_operand (op), 0")	444	(match_code "mem")
445	(match_code "mem"))
446	{	445	{
447	rtx base;	446	rtx base;
448	int offset;	447	int offset;
Lines 486-493 Link Here
486	;; Similar, but return 1 if OP is a MEM which is not alignable.	485	;; Similar, but return 1 if OP is a MEM which is not alignable.
487		486
488	(define_special_predicate "unaligned_memory_operand"	487	(define_special_predicate "unaligned_memory_operand"
489	(ior (match_test "op = resolve_reload_operand (op), 0")	488	(match_code "mem")
490	(match_code "mem"))
491	{	489	{
492	rtx base;	490	rtx base;
493	int offset;	491	int offset;
Lines 549-562 Link Here
549	return false;	547	return false;
550	})	548	})
551		549
552	;; Return 1 is OP is a memory location that is not a reference
553	;; (using an AND) to an unaligned location. Take into account
554	;; what reload will do.
555	(define_special_predicate "normal_memory_operand"
556	(ior (match_test "op = resolve_reload_operand (op), 0")
557	(and (match_code "mem")
558	(match_test "GET_CODE (XEXP (op, 0)) != AND"))))
559
560	;; Returns 1 if OP is not an eliminable register.	550	;; Returns 1 if OP is not an eliminable register.
561	;;	551	;;
562	;; This exists to cure a pathological failure in the s8addq (et al) patterns,	552	;; This exists to cure a pathological failure in the s8addq (et al) patterns,