text:
|/* Language independent return value optimizations
|Copyright (C) 2004, 2005 Free Software Foundation, Inc.
|This file is part of GCC.
|GCC is free software; you can redistribute it and/or modify
|it under the terms of the GNU General Public License as published by
|the Free Software Foundation; either version 2, or (at your option)
|any later version.
|GCC is distributed in the hope that it will be useful,
|but WITHOUT ANY WARRANTY; without even the implied warranty of
|MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|GNU General Public License for more details.
|You should have received a copy of the GNU General Public License
|along with GCC; see the file COPYING. If not, write to
|the Free Software Foundation, 59 Temple Place - Suite 330,
|Boston, MA 02111-1307, USA. */
|#include "config.h"
|#include "system.h"
|#include "coretypes.h"
|#include "tm.h"
|#include "tree.h"
|#include "rtl.h"
|#include "function.h"
|#include "basic-block.h"
|#include "expr.h"
|#include "diagnostic.h"
|#include "tree-flow.h"
|#include "timevar.h"
|#include "tree-dump.h"
|#include "tree-pass.h"
|#include "langhooks.h"
|/* This file implements return value optimizations for functions which
|return aggregate types.
|Basically this pass searches the function for return statements which
|return a local aggregate. When converted to RTL such statements will
|generate a copy from the local aggregate to final return value destination
|mandated by the target's ABI.
|That copy can often be avoided by directly constructing the return value
|into the final destination mandated by the target's ABI.
|This is basically a generic equivalent to the C++ front-end's
|Named Return Value optimization. */
|struct nrv_data
|/* This is the temporary (a VAR_DECL) which appears in all of
|this function's RETURN_EXPR statements. */
|tree var;
|/* This is the function's RESULT_DECL. We will replace all occurrences
|of VAR with RESULT_DECL when we apply this optimization. */
|tree result;
|static tree finalize_nrv_r (tree *, int *, void *);
|/* Callback for the tree walker.
|If TP refers to a RETURN_EXPR, then set the expression being returned
|to nrv_data->result.
|If TP refers to nrv_data->var, then replace nrv_data->var with
|If we reach a node where we know all the subtrees are uninteresting,
|then set *WALK_SUBTREES to zero. */
|static tree
|finalize_nrv_r (tree *tp, int *walk_subtrees, void *data)
|struct nrv_data *dp = (struct nrv_data *)data;
|/* No need to walk into types. */
|if (TYPE_P (*tp))
|*walk_subtrees = 0;
|/* If this is a RETURN_EXPR, set the expression being returned to RESULT. */
|else if (TREE_CODE (*tp) == RETURN_EXPR)
|TREE_OPERAND (*tp, 0) = dp->result;
|/* Otherwise replace all occurrences of VAR with RESULT. */
|else if (*tp == dp->var)
|*tp = dp->result;
|/* Keep iterating. */
|return NULL_TREE;
|/* Main entry point for return value optimizations.
|If this function always returns the same local variable, and that
|local variable is an aggregate type, then replace the variable with
|the function's DECL_RESULT.
|This is the equivalent of the C++ named return value optimization
|applied to optimized trees in a language independent form. If we
|ever encounter languages which prevent this kind of optimization,
|then we could either have the languages register the optimization or
|we could change the gating function to check the current language. */
|static void
|tree_nrv (void)
|tree result = DECL_RESULT (current_function_decl);
|tree result_type = TREE_TYPE (result);
|tree found = NULL;
|basic_block bb;
|struct nrv_data data;
|/* If this function does not return an aggregate type in memory, then
|there is nothing to do. */
|if (!aggregate_value_p (result, current_function_decl))
|/* Look through each block for suitable return expressions. RETURN_EXPRs
|end basic blocks, so we only have to look at the last statement in
|each block. That makes this very fast. */
|FOR_EACH_BB (bb)
|tree stmt = last_stmt (bb);
|if (stmt && TREE_CODE (stmt) == RETURN_EXPR)
|tree ret_expr = TREE_OPERAND (stmt, 0);
|/* This probably should not happen, but just to be safe do
|not perform NRV optimizations if only some of the return
|statement return a value. */
|if (!ret_expr
||| TREE_CODE (ret_expr) != MODIFY_EXPR
||| TREE_CODE (TREE_OPERAND (ret_expr, 0)) != RESULT_DECL)
|/* Now verify that this return statement uses the same value
|as any previously encountered return statement. */
|if (found != NULL)
|/* If we found a return statement using a different variable
|than previous return statements, then we can not perform
|NRV optimizations. */
|if (found != TREE_OPERAND (ret_expr, 1))
|found = TREE_OPERAND (ret_expr, 1);
|/* The returned value must be a local automatic variable of the
|same type and alignment as the function's result. */
|if (TREE_CODE (found) != VAR_DECL
||| TREE_THIS_VOLATILE (found)
||| DECL_CONTEXT (found) != current_function_decl
||| TREE_STATIC (found)
||| TREE_ADDRESSABLE (found)
||| DECL_ALIGN (found) > DECL_ALIGN (result)
||| !lang_hooks.types_compatible_p (TREE_TYPE (found),
|if (!found)
|/* If dumping details, then note once and only the NRV replacement. */
|if (dump_file && (dump_flags & TDF_DETAILS))
|fprintf (dump_file, "NRV Replaced: ");
|print_generic_expr (dump_file, found, dump_flags);
|fprintf (dump_file, " with: ");
|print_generic_expr (dump_file, result, dump_flags);
|fprintf (dump_file, "\n");
|/* At this point we know that all the return statements return the
|same local which has suitable attributes for NRV. Copy debugging
|information from FOUND to RESULT. */
|DECL_NAME (result) = DECL_NAME (found);
|DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
|DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
|TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (found);
|/* Now walk through the function changing all references to VAR to be
|data.var = found;
|data.result = result;
|FOR_EACH_BB (bb)
|block_stmt_iterator bsi;
|for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
|walk_tree (bsi_stmt_ptr (bsi), finalize_nrv_r, &data, 0);
|/* FOUND is no longer used. Ensure it gets removed. */
|var_ann (found)->used = 0;
|struct tree_opt_pass pass_nrv =
|"nrv", /* name */
|NULL, /* gate */
|tree_nrv, /* execute */
|NULL, /* sub */
|NULL, /* next */
|0, /* static_pass_number */
|TV_TREE_NRV, /* tv_id */
|PROP_cfg, /* properties_required */
|0, /* properties_provided */
|0, /* properties_destroyed */
|0, /* todo_flags_start */
|TODO_dump_func | TODO_ggc_collect, /* todo_flags_finish */
|0 /* letter */


text:
Geometrico 9D Charger Plate
Descriptions & details
D&G Design Geometric tableware collections are a modern take on Deruta geometric designs.
You can mix and match their colorful, stylish designs to create unique combinations.
We are constantly adding new pieces to every collection.
Contact us if you are looking for a particular kitchen or serving item.
Handmade & hand-painted in Deruta, Italy
Material: ceramic
Food-safe & compliant with FDA regulations - lead and cadmium free
Dishwasher safe. Not recommended for microwave use
The artist
D&G - Demet and Giovanni - are the artisans breathing new life into Deruta pottery.
They have formidable creativity and strong technical skills. Starting from traditional geometric patterns, they have given a contemporary edge to many classic Deruta patterns and created new, original tableware collections that have become instantly popular.
Deruta is a small town in Umbria, in the heart of Italy. It has been one of the most vital centers for the production of Italian ceramics since the Renaissance (15th century). Today, Deruta is highly regarded worldwide for the fine quality and beauty of its pottery.
Delivery and refunds
Handcrafted for you, ships in approx. 8 weeks
Insured express delivery from Italy
Shipping charges to the US:
- shipping to the US is $30 - free shipping over $250
- Customs duties are always on us
For any other destination, please view our Shipping Policy
Changed your mind? Please, read our Return Policy

subset: commoncrawl


text:
- Home
- About Me
- About this Blog
- Recipe Index
- Reflections and Reviews
- Kitchen Notes
- Blogroll
Tuesday, 22 January 2008
Pea and Garlic Soup
Thomas Nash, 16th Century poet
Garlic is well known for its pungent smell and ability to repel vampires (and the above quote makes me think it could explain strange men hanging around nightclubs like a bad smell!). Some people find the smell repugnant. I once shared a house with a woman who insisted on using a garlic crusher because she swore she hadn't been able to find a boyfriend when she had chopped it by hand and the smell got into her fingers. I have always been of the belief that if everyone eats lots of garlic you don't notice it so much. And surely it is hard to avoid eating a lot of it a lot of the time!
Colin Spencer revels in garlic – 'the smell I inhale like perfume, the aroma on others breath is a sign of life and its celebration.' Not surprising coming from a man who says he has happily peeled 200 garlic clove for garlic soup. One can only assume that he didn't eat it alone in one sitting!
Nigella delights in the brilliant colours which she describes as having a 'day-glo vibrancy'. The bright green is so lovely that it seems a shame to eat it, but eat it we did with much enjoyment. Roasting mellows the sharp edges and intensifies the flavour of the garlic leaving it with a sweet pungency that enhances the peas. Served with pumpkin scones, the soup made a simple but very satisfying supper.
I am sending this recipe to Sunita of Sunita's World for her Think Spice event which is all about Garlic in January.
Pea and garlic soup
(adapted from Nigella Lawson)
serves 2 (as dinner with bread or scones)
1 head of garlic
1 tsp olive oil
2 cups frozen peas
2 cups stock
Freshly grated parmesan cheese
Freshly ground black pepper
Slice the top off the head of garlic so you have just nipped the top of all the cloves (or almost all of them). Place on a square of foil and drizzle with oil. Bring edges of foil together to make a bag that is sealed at the top with a twist. Roast in 200 C oven for about 30-40 minutes. (Nigella said 60 minutes but that was too long for me because the cloves were already starting to brown slightly by about 35-40 minutes.) Garlic cloves should be soft and easy to squeeze out of their skin. (Although, unless you have asbestos hands, you might want to cool it a little before squeezing cloves out.)
Place garlic cloves, peas and stock in small saucepan and bring to the boil. Use hand held blender to puree soup. Serve with some freshly grated parmesan cheese and black pepper.
Update October 2013: I noticed that in The Guardian Word of Mouth blog was linking to this post and was so mortified by the terrible photo that I have made the soup again today so I could update the photos. It is less dayglo than the original due to some darker homemade vegie stock but every bit as delicious! And check out The Guardian link for more information on garlic varieties.
On the Stereo:
Harry Smith Anthology of American Folk Music (promo sampler): Various Artists
8 comments:
- Anonymous22 January 2008 at 23:56
Oh, YUM. I adore garlic. We eat it here roasted, as you show it, just spread on bread or crackers. But the pea and garlic combo does sound great (and, truly, "day-glo"!).ReplyDelete
And coincidentally, I also just tried out your pumpkin scones (or are they biscuits?) yesterday, though I used sweet potato in place of the pumpkin. They turned out perfect--delicious, and very light. Will be blogging about it this week as part of the sweet potato "series."
thanks Ricki - I have always enjoyed roasted garlic with a roast dinner but it does add real depth of flavour to this soup.ReplyDelete
Glad you enjoyed the pumpkin scones - I could (and did the other day) eat them for breakfast, lunch and tea! Look forward to your blogging about them
I love garlic, and have eaten so much that I think I'm immune to it now - I only notice it when it's missing!ReplyDelete
I'm with you Vicki - garlic seems to go so well in everything.ReplyDelete
Thanks for sending over that lovely looking soup.ReplyDelete
thanks Sunita - was good to be challenged to think of a dish to feature garlic rather than just having it in the background as I do often do!ReplyDelete
I adore pea soup, in fact just finished the last I had in the freezer. What gets my attention here is the added garlic. I cannot find a reason why I have not added garlic to my pea soup, I add it to everything else! Will give your recipe a go next time. And wow, the color is awesome!ReplyDelete
thanks Deb - yes peas are such a beautiful colour. I recommend trying the roasted garlic - such an easy way to add a lot of flavour.ReplyDelete
Thanks for dropping by. I love hearing from you. Please share your thoughts and questions. Annoyingly the spammers are bombarding me so I have turned on the pesky captcha code (refresh to find an easy one if you don't like the first one)